adminizer 4.2.0 → 4.3.0-build.73

package/lib/v4/model/adapter/sequelize.js

@@ -170,6 +170,10 @@ export class SequelizeModel extends AbstractModel {
             if (value === null) {
                 result[targetKey] = { [Op.is]: null };
             }
+            else if (Array.isArray(value)) {
+                // ✅ Обработка массивов - используем оператор IN
+                result[targetKey] = { [Op.in]: value };
+            }
             else if (typeof value === "object" && !Array.isArray(value)) {
                 const operatorEntries = Object.entries(value)
                     .filter(([_, v]) => v !== undefined && v !== null)

package/lib/v4/model/adapter/typeorm.d.ts

@@ -9,6 +9,7 @@ export declare class TypeORMModel<T> extends AbstractModel<T> {
     protected _destroy(criteria: Partial<T>): Promise<T[]>;
     protected _destroyOne(criteria: Partial<T>): Promise<T | null>;
     protected _find(criteria: Partial<T>, options: FindOptions | undefined): Promise<T[]>;
+    private _convertCriteriaForTypeORM;
     protected _findOne(criteria: Partial<T>): Promise<T | null>;
     protected _update(criteria: Partial<T>, data: Partial<T>): Promise<T[]>;
     protected _updateOne(criteria: Partial<T>, data: Partial<T>): Promise<T | null>;

package/lib/v4/model/adapter/typeorm.js

@@ -27,7 +27,27 @@ export class TypeORMModel extends AbstractModel {
         return null;
     }
     async _find(criteria, options) {
-        return this.repository.find({ where: criteria, ...options });
+        // Преобразуем критерии для поддержки массивов
+        const where = this._convertCriteriaForTypeORM(criteria);
+        return this.repository.find({ where, ...options });
+    }
+    _convertCriteriaForTypeORM(criteria) {
+        const result = {};
+        for (const key in criteria) {
+            const value = criteria[key];
+            if (Array.isArray(value)) {
+                // Для массивов используем оператор IN
+                result[key] = { $in: value };
+            }
+            else if (typeof value === 'object' && value !== null) {
+                // Обработка вложенных объектов с операторами
+                result[key] = value;
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
     }
     async _findOne(criteria) {
         return this.repository.findOne({ where: criteria });

package/lib/v4/notifications/AbstractNotificationService.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter } from 'events';
+import { Adminizer } from '../../Adminizer';
+import { INotification, INotificationEvent } from '../../../interfaces/types';
+export declare abstract class AbstractNotificationService extends EventEmitter {
+    protected clients: 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;
+    removeClient(clientId: string): 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[]>;
+    markAsRead(userId: number, id: string): Promise<void>;
+}

package/lib/v4/notifications/AbstractNotificationService.js

@@ -0,0 +1,149 @@
+import { EventEmitter } from 'events';
+import { Adminizer } from '../../Adminizer';
+export class AbstractNotificationService extends EventEmitter {
+    clients = new Map();
+    adminizer;
+    constructor(adminizer) {
+        super();
+        this.adminizer = adminizer;
+    }
+    // Добавление клиента
+    addClient(clientId, sendFn) {
+        this.clients.set(clientId, sendFn);
+        Adminizer.log.info(`[${this.notificationClass}] Client ${clientId} connected. Total: ${this.clients.size}`);
+    }
+    // Удаление клиента
+    removeClient(clientId) {
+        this.clients.delete(clientId);
+        Adminizer.log.info(`[${this.notificationClass}] Client ${clientId} disconnected. Total: ${this.clients.size}`);
+    }
+    // abstract getNotifications(userId?: number, limit?: number, unreadOnly?: boolean): Promise<INotification[]>;
+    // Рассылка события всем клиентам
+    broadcast(event) {
+        this.clients.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) {
+        const sendFn = this.clients.get(clientId);
+        if (sendFn) {
+            const heartbeatEvent = {
+                type: 'heartbeat',
+                data: 'ping'
+            };
+            sendFn(heartbeatEvent);
+        }
+    }
+    // Генерация ID
+    generateId() {
+        return `${this.notificationClass}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    // Получение количества подключенных клиентов
+    getClientCount() {
+        return this.clients.size;
+    }
+    // Метод для создания записи в 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 = 50, 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
+                },
+                include: ['notificationap']
+            });
+            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;
+            }
+            let notificationsDB;
+            if (query.id.length === 0)
+                return [];
+            notificationsDB = await this.adminizer.modelHandler.model.get('notificationap')["_find"]({
+                where: query,
+                sort: 'createdAt DESC',
+                limit: limit
+            });
+            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;
+        }
+        catch (error) {
+            Adminizer.log.error('Error fetching 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);
+        }
+    }
+}

package/lib/v4/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/v4/notifications/GeneralNotificationService.js

@@ -0,0 +1,56 @@
+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 {
+                            await this.createUserNotification(notificationDB.id, user.id);
+                        }
+                        catch (error) {
+                            Adminizer.log.error('Error creating UserNotificationAP:', error);
+                        }
+                    }
+                }
+                const event = {
+                    type: 'notification',
+                    data: {
+                        ...notificationDB.toJSON(),
+                        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/v4/notifications/NotificationHandler.d.ts

@@ -0,0 +1,69 @@
+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;
+    /**
+     * Remove a notification service
+     * @param notificationClass
+     */
+    removeService(notificationClass: string): 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>;
+    /**
+     * Get notifications by class
+     * @param notificationClass
+     * @param userId
+     * @param limit
+     * @param unreadOnly
+     */
+    getNotifications(notificationClass: string, userId?: number, limit?: number, unreadOnly?: boolean): Promise<INotification[]>;
+    /**
+     * Get all notifications for a user
+     * @param user
+     * @param limit
+     * @param unreadOnly
+     */
+    getUserNotifications(user: any, limit?: number, unreadOnly?: boolean): Promise<INotification[]>;
+    /**
+     * Mark a notification as read
+     * @param notificationClass
+     * @param id
+     * @param userId
+     */
+    markAsRead(notificationClass: string, id: string, userId: number): Promise<void>;
+    /**
+     * Check if user is admin
+     * @param user
+     * @private
+     */
+    private isAdmin;
+    /**
+     * Get client count for a notification class
+     * @param notificationClass
+     */
+    getClientCount(notificationClass: string): number;
+    /**
+     * Get total client count
+     */
+    getTotalClientCount(): number;
+}

package/lib/v4/notifications/NotificationHandler.js

@@ -0,0 +1,127 @@
+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}`);
+    }
+    /**
+     * Remove a notification service
+     * @param notificationClass
+     */
+    removeService(notificationClass) {
+        if (this.services.has(notificationClass)) {
+            this.services.delete(notificationClass);
+            Adminizer.log.info(`Notification service removed: ${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);
+    }
+    /**
+     * Get notifications by class
+     * @param notificationClass
+     * @param userId
+     * @param limit
+     * @param unreadOnly
+     */
+    async getNotifications(notificationClass, userId, limit, unreadOnly) {
+        const service = this.getService(notificationClass);
+        if (!service) {
+            throw new Error(`Notification service not found: ${notificationClass}`);
+        }
+        return service.getNotifications(userId, limit, unreadOnly);
+    }
+    /**
+     * Get all notifications for a user
+     * @param user
+     * @param limit
+     * @param unreadOnly
+     */
+    async getUserNotifications(user, limit = 50, unreadOnly = false) {
+        const allNotifications = [];
+        for (const service of this.getAllServices()) {
+            // Для системных уведомлений проверяем права админа
+            if (service.notificationClass === 'system') {
+                if (this.isAdmin(user)) {
+                    const notifications = await service.getNotifications(user.id, limit, unreadOnly);
+                    allNotifications.push(...notifications);
+                }
+            }
+            else {
+                // Для остальных уведомлений получаем по пользователю
+                const notifications = await service.getNotifications(user.id, limit, unreadOnly);
+                allNotifications.push(...notifications);
+            }
+        }
+        // Сортируем по дате создания
+        return allNotifications.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()).slice(0, limit);
+    }
+    /**
+     * Mark a notification as read
+     * @param notificationClass
+     * @param id
+     * @param userId
+     */
+    async markAsRead(notificationClass, id, userId) {
+        const service = this.getService(notificationClass);
+        if (!service) {
+            throw new Error(`Notification service not found: ${notificationClass}`);
+        }
+        return service.markAsRead(userId, id);
+    }
+    /**
+     * Check if user is admin
+     * @param user
+     * @private
+     */
+    isAdmin(user) {
+        if (!user)
+            return false;
+        return user.isAdministrator === true;
+    }
+    /**
+     * Get client count for a notification class
+     * @param notificationClass
+     */
+    getClientCount(notificationClass) {
+        const service = this.getService(notificationClass);
+        return service ? service.getClientCount() : 0;
+    }
+    /**
+     * Get total client count
+     */
+    getTotalClientCount() {
+        return this.getAllServices().reduce((total, service) => total + service.getClientCount(), 0);
+    }
+}

package/lib/v4/notifications/SystemNotificationService.d.ts

@@ -0,0 +1,18 @@
+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): void;
+    removeClientFromChannel(clientId: string, channel: string): void;
+    removeClientFromAllChannels(clientId: string): 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>;
+}

package/lib/v4/notifications/SystemNotificationService.js

@@ -0,0 +1,123 @@
+import { AbstractNotificationService } from './AbstractNotificationService';
+import { Adminizer } from '../../Adminizer';
+export class SystemNotificationService extends AbstractNotificationService {
+    notificationClass = 'system';
+    icon = 'settings';
+    iconColor = '#1eb707';
+    // Добавляем каналы для CRUD операций
+    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"]({ isAdministrator: 1 });
+                for (const user of users) {
+                    try {
+                        await this.createUserNotification(notificationDB.id, user.id);
+                    }
+                    catch (error) {
+                        Adminizer.log.error('Error creating UserNotificationAP:', error);
+                    }
+                }
+                const event = {
+                    type: 'notification',
+                    data: {
+                        ...notificationDB.toJSON(),
+                        icon: {
+                            icon: this.icon,
+                            iconColor: this.iconColor
+                        },
+                    },
+                    notificationClass: this.notificationClass,
+                    userId: notification.userId ?? null,
+                    channel: notification.channel // Добавляем информацию о канале
+                };
+                // Отправляем на все каналы или на конкретный канал
+                if (notification.channel) {
+                    this.broadcastToChannel(notification.channel, event);
+                }
+                else {
+                    this.broadcast(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(channel, event) {
+        const channelClients = this.crudChannels.get(channel);
+        if (channelClients) {
+            channelClients.forEach(clientId => {
+                const sendFn = this.clients.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) {
+        if (!this.crudChannels.has(channel)) {
+            this.crudChannels.set(channel, new Set());
+        }
+        this.crudChannels.get(channel).add(clientId);
+        Adminizer.log.info(`[${this.notificationClass}] Client ${clientId} added to channel ${channel}`);
+    }
+    // Удаляем клиента из канала
+    removeClientFromChannel(clientId, channel) {
+        const channelClients = this.crudChannels.get(channel);
+        if (channelClients) {
+            channelClients.delete(clientId);
+            Adminizer.log.info(`[${this.notificationClass}] Client ${clientId} removed from channel ${channel}`);
+        }
+    }
+    // Удаляем клиента из всех каналов
+    removeClientFromAllChannels(clientId) {
+        this.crudChannels.forEach((clients, channel) => {
+            clients.delete(clientId);
+            Adminizer.log.info(`[${this.notificationClass}] Client ${clientId} removed from channel ${channel}`);
+        });
+    }
+    // Переопределяем removeClient для очистки каналов
+    removeClient(clientId) {
+        super.removeClient(clientId);
+        this.removeClientFromAllChannels(clientId);
+    }
+    // Специальный метод для системных событий с указанием канала
+    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);
+    }
+}

package/models/NotificationAP.d.ts

@@ -0,0 +1,36 @@
+import { Model } from "sequelize";
+declare const _default: {
+    id: {
+        type: string;
+        autoIncrement: boolean;
+        primaryKey: boolean;
+    };
+    title: {
+        type: string;
+    };
+    message: {
+        type: string;
+    };
+    notificationClass: {
+        type: string;
+    };
+    channel: {
+        type: string;
+    };
+    metadata: {
+        type: string;
+    };
+};
+export default _default;
+export interface NotificationAP {
+    id: string;
+    title: string;
+    message: string;
+    channel: string;
+    notificationClass: string;
+    metadata?: Record<string, unknown>;
+    createdAt: Date;
+}
+export interface NotificationAPModel extends Model<NotificationAP>, NotificationAP {
+    toJSON(): NotificationAP;
+}