adminizer 4.2.0 → 4.3.0-build.74

package/lib/Adminizer.js

@@ -29,6 +29,7 @@ import { bindControls } from "../system/bindControls";
 import { ControlsHandler } from "./v4/controls/ControlsHandler";
 import { CatalogHandler } from "./v4/catalog/CatalogHandler";
 import { v4 as uuid } from "uuid";
+import { bindNotifications } from "../system/bindNotifications";
 export class Adminizer {
     // Preconfigures
     /**
@@ -45,6 +46,7 @@ export class Adminizer {
     accessRightsHelper;
     configHelper;
     menuHelper;
+    notificationHandler;
     modelHandler;
     widgetHandler;
     vite;
@@ -52,6 +54,8 @@ export class Adminizer {
     catalogHandler;
     // Constants
     jwtSecret = process.env.JWT_SECRET ?? uuid();
+    // External auth handler
+    authHandler;
     static logger = winston.createLogger({
         level: process.env.LOG_LEVEL ?? "debug",
         format: winston.format.combine(winston.format.timestamp(), winston.format.printf(({ timestamp, level, message, ...meta }) => {
@@ -68,8 +72,35 @@ export class Adminizer {
         this._emitter = new EventEmitter();
         this.ormAdapters = ormAdapters;
     }
+    /**
+     * Registers an external authentication handler. If a user is not found in UserAP
+     * during login, this handler will be invoked to authenticate against an external source.
+     */
+    setAuthHandler(handler) {
+        this.authHandler = handler;
+    }
     getMiddleware() {
-        return (req, res) => {
+        return (req, res, next) => {
+            try {
+                const prefix = (this.config && this.config.routePrefix) ? String(this.config.routePrefix) : '';
+                const normalizedPrefix = prefix.replace(/\/+/g, '/').replace(/\/+$/g, '');
+                if (normalizedPrefix) {
+                    const url = req.url || req.originalUrl || '';
+                    const conditions = [
+                        url === normalizedPrefix,
+                        url.startsWith(normalizedPrefix + '/')
+                    ];
+                    if (process.env.IS_SAILS === undefined) {
+                        conditions.push(url.startsWith('/public'));
+                    }
+                    if (!conditions.some(condition => condition)) {
+                        return typeof next === 'function' ? next() : undefined;
+                    }
+                }
+            }
+            catch (e) {
+                // fall back to handling the request
+            }
             this.app(req, res, (err) => {
                 if (err) {
                     console.error("Error in Adminizer", err);
@@ -77,6 +108,9 @@ export class Adminizer {
                     res.end('Internal Server Error');
                 }
                 else {
+                    if (typeof next === 'function') {
+                        return next();
+                    }
                     res.writeHead(404, { 'Content-Type': 'text/plain' });
                     res.end('Route Not Found in Adminizer');
                 }
@@ -173,6 +207,9 @@ export class Adminizer {
         // bind Inertia
         bindInertia(this);
         await bindAuthorization(this);
+        // Bind notifications
+        if (this.config.notification.enabled)
+            await bindNotifications(this);
         await Router.bind(this); // must be after binding policies and req/res functions
         /**
          * Adminizer loaded
@@ -180,6 +217,29 @@ export class Adminizer {
          */
         this._emitter.emit('adminizer:loaded');
     }
+    // Хелпер для отправки уведомлений
+    async sendNotification(notification) {
+        const notificationClass = notification.notificationClass || 'general';
+        return this.notificationHandler.dispatchNotification(notificationClass, notification);
+    }
+    // Хелпер для системных событий
+    async logSystemEvent(title, message, metadata) {
+        const systemNotificationService = this.notificationHandler.getService('system');
+        return systemNotificationService.logSystemEvent(title, message, 'system', metadata);
+    }
+    // Хелпер для CRUD системных событий
+    async logSystemCreatedEvent(title, message, metadata) {
+        const systemNotificationService = this.notificationHandler.getService('system');
+        return systemNotificationService.logCreatedEvent(title, message, metadata);
+    }
+    async logSystemUpdatedEvent(title, message, metadata) {
+        const systemNotificationService = this.notificationHandler.getService('system');
+        return systemNotificationService.logUpdatedEvent(title, message, metadata);
+    }
+    async logSystemDeletedEvent(title, message, metadata) {
+        const systemNotificationService = this.notificationHandler.getService('system');
+        return systemNotificationService.logDeletedEvent(title, message, metadata);
+    }
     get emitter() {
         return this._emitter;
     }

package/lib/media-manager/AbstractMediaManager.js

@@ -50,8 +50,8 @@ export class AbstractMediaManager {
             adminizer.accessRightsHelper.registerToken({
                 id: `mediaManager-${this.id}`,
                 name: this.id,
-                description: `Access to edit catalog for ${this.id}`,
-                department: 'catalog'
+                description: `Access to edit media-manager for ${this.id}`,
+                department: 'media-manager',
             });
         }, 100);
     }

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>;
+}