adminizer 4.2.0 → 4.3.0-build.74

package/controllers/add.js

@@ -87,6 +87,8 @@ export default async function add(req, res) {
         }
         try {
             let record = await entity.model.create(reqData, dataAccessor);
+            // log system event notification
+            await req.adminizer.logSystemCreatedEvent(req.i18n.__('Created'), `user ${req.user.login} ${req.i18n.__('create')} ${entity.name} ${record.id}`, { test: 'test' });
             // save associations media to json
             await saveRelationsMediaManager(fields, rawReqData, entity.model.identity, record.id);
             Adminizer.log.debug(`A new record was created: `, record);

package/controllers/edit.js

@@ -1,10 +1,12 @@
 import { ControllerHelper } from "../helpers/controllerHelper";
 import { RequestProcessor } from "../lib/requestProcessor";
 import { FieldsHelper } from "../helpers/fieldsHelper";
+import { diff } from 'deep-object-diff';
 import { getRelationsMediaManager, saveRelationsMediaManager } from "../lib/media-manager/helpers/MediaManagerHelper";
 import { DataAccessor } from "../lib/v4/DataAccessor";
 import { Adminizer } from "../lib/Adminizer";
 import inertiaAddHelper from "../helpers/inertiaAddHelper";
+import { formatChanges, sanitizeForDiff } from "../helpers/diffHelpers";
 export default async function edit(req, res) {
     //Check id
     if (!req.params.id) {
@@ -113,6 +115,18 @@ export default async function edit(req, res) {
         try {
             let newRecord = await entity.model.update(params, reqData, dataAccessor);
             await saveRelationsMediaManager(fields, rawReqData, entity.model.identity, newRecord[0].id);
+            // Создаем clean объекты для сравнения (исключаем системные поля)
+            const cleanOldRecord = sanitizeForDiff(record);
+            const cleanNewRecord = sanitizeForDiff(newRecord[0]);
+            // Получаем diff
+            const changesDiff = diff(cleanOldRecord, cleanNewRecord);
+            // Форматируем для лога
+            const formattedChanges = formatChanges(changesDiff, cleanOldRecord, cleanNewRecord);
+            // log system event notification
+            await req.adminizer.logSystemUpdatedEvent(req.i18n.__('Updated'), `user ${req.user.login} ${req.i18n.__('update')} ${entity.name} ${record.id}`, {
+                changes: formattedChanges,
+                summary: `${req.i18n.__('Changes')} ${Object.keys(formattedChanges).length} ${req.i18n.__('fields')}`
+            });
             Adminizer.log.debug(`Record was updated: `, newRecord);
             if (req.body.jsonPopupCatalog) {
                 return res.json({ record: newRecord });

package/controllers/login.js

@@ -14,25 +14,25 @@ export default async function login(req, res) {
             let login = req.body.login;
             let password = req.body.password;
             let captchaSolution = req.body.captchaSolution;
-            let user;
-            try {
-                // TODO refactor CRUD functions for DataAccessor usage
-                user = await req.adminizer.modelHandler.model.get("UserAP")["_findOne"]({ login: login });
-            }
-            catch (e) {
-                return res.status(500).send({ error: e.message || 'Internal Server Error' });
-            }
+            // Handle pretend (impersonation) first against internal users list
             if (req.body.pretend) {
-                if (!user) {
-                    return res.sendStatus(404);
+                try {
+                    // TODO refactor CRUD functions for DataAccessor usage
+                    const pretendUser = await req.adminizer.modelHandler.model.get("UserAP")["_findOne"]({ login });
+                    if (!pretendUser) {
+                        return res.sendStatus(404);
+                    }
+                    if (req.user.isAdministrator) {
+                        req.session.userPretended = pretendUser;
+                        return req.Inertia.redirect(`${req.adminizer.config.routePrefix}`);
+                    }
+                    return req.Inertia.redirect(`${req.adminizer.config.routePrefix}/`);
                 }
-                if (req.user.isAdministrator) {
-                    req.session.userPretended = user;
-                    // return res.sendStatus(200);
-                    return req.Inertia.redirect(`${req.adminizer.config.routePrefix}`);
+                catch (e) {
+                    return res.status(500).send({ error: e.message || 'Internal Server Error' });
                 }
-                return req.Inertia.redirect(`${req.adminizer.config.routePrefix}/`);
             }
+            let authenticatedExternally = false;
             // Verify CAPTCHA solution if enabled
             if (req.adminizer.config.auth.captcha !== false) {
                 const isCaptchaValid = powCaptcha.check(captchaSolution, `login:${req.ip}`);
@@ -40,17 +40,22 @@ export default async function login(req, res) {
                     return inertiaAdminMessage(req, "Invalid CAPTCHA solution", 'captchaSolution');
                 }
             }
-            if (!user) {
-                return inertiaAdminMessage(req, "Wrong username", 'login');
+            // First check UserAP model (local auth)
+            let user;
+            try {
+                // TODO refactor CRUD functions for DataAccessor usage
+                user = await req.adminizer.modelHandler.model.get("UserAP")["_findOne"]({ login: login });
+            }
+            catch (e) {
+                return res.status(500).send({ error: e.message || 'Internal Server Error' });
             }
-            else {
-                if (req.adminizer.config.registration.confirmationRequired && !user.isConfirmed && !user.isAdministrator) {
-                    //Here we use the captchaSolution key to output messages unrelated to the form fields.
+            if (user) {
+                // User found in UserAP, validate password
+                if (req.adminizer.config.registration.confirmationRequired && user.isConfirmed === false && !user.isAdministrator) {
                     return inertiaAdminMessage(req, "Profile is not confirmed, please contact to administrator", 'captchaSolution');
                 }
                 if (passwordHash.verify(login + password + process.env.AP_PASSWORD_SALT, user.passwordHashed)) {
                     if (user.expires && Date.now() > Date.parse(user.expires)) {
-                        //Here we use the captchaSolution key to output messages unrelated to the form fields.
                         return inertiaAdminMessage(req, "Profile expired, contact the administrator", 'captchaSolution');
                     }
                     const token = signUser(user, req.adminizer.jwtSecret);
@@ -66,6 +71,36 @@ export default async function login(req, res) {
                     return inertiaAdminMessage(req, "Wrong password", 'password');
                 }
             }
+            // If user not found in UserAP and external auth handler is configured, try external auth
+            if (typeof req.adminizer.authHandler === 'function') {
+                try {
+                    const extUser = await req.adminizer.authHandler(req, login, password);
+                    if (!extUser) {
+                        return inertiaAdminMessage(req, "Wrong username or password", 'login');
+                    }
+                    const externalUser = extUser;
+                    if (req.adminizer.config.registration.confirmationRequired && externalUser.isConfirmed === false && !externalUser.isAdministrator) {
+                        return inertiaAdminMessage(req, "Profile is not confirmed, please contact to administrator", 'captchaSolution');
+                    }
+                    if (externalUser.expires && Date.now() > Date.parse(externalUser.expires)) {
+                        return inertiaAdminMessage(req, "Profile expired, contact the administrator", 'captchaSolution');
+                    }
+                    const token = signUser(externalUser, req.adminizer.jwtSecret);
+                    res.setHeader('Set-Cookie', serialize('adminizer_jwt', token, {
+                        httpOnly: true,
+                        sameSite: 'lax',
+                        path: '/',
+                        maxAge: 60 * 60 * 24 * 7 * 2,
+                    }));
+                    return req.Inertia.redirect(`${req.adminizer.config.routePrefix}`);
+                }
+                catch (err) {
+                    Adminizer.log.error('External auth handler error', err);
+                    return res.status(500).send({ error: 'Internal Server Error' });
+                }
+            }
+            // If neither UserAP nor external auth worked
+            return inertiaAdminMessage(req, "Wrong username or password", 'login');
         }
         if (req.method.toUpperCase() === "GET") {
             // Generate new CAPTCHA task if enabled

package/controllers/media-manager/mediaManagerApi.js

@@ -9,7 +9,7 @@ export async function mediaManagerController(req, res) {
         if (!req.user) {
             return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
         }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`catalog-${id}`, req.user)) {
+        else if (!req.adminizer.accessRightsHelper.hasPermission(`mediaManager-${id}`, req.user)) {
             return res.sendStatus(403);
         }
     }

package/controllers/notifications/NotificationController.d.ts

@@ -0,0 +1,11 @@
+export declare class NotificationController {
+    static viewAll(req: ReqType, res: ResType): Promise<void | import("express").Response<any, Record<string, any>>>;
+    static getNotificationsStream(req: ReqType, res: ResType): Promise<void>;
+    static getNotificationsByClass(req: ReqType, res: ResType): Promise<void>;
+    static getUserNotifications(req: ReqType, res: ResType): Promise<void>;
+    static getAllUserNotifications(req: ReqType, res: ResType): Promise<void>;
+    static markAsRead(req: ReqType, res: ResType): Promise<void>;
+    static sendNotification(req: ReqType, res: ResType): Promise<void>;
+    private static isAdmin;
+    private static checkPermission;
+}

package/controllers/notifications/NotificationController.js

@@ -0,0 +1,203 @@
+import { Adminizer } from '../../lib/Adminizer';
+export class NotificationController {
+    static async viewAll(req, res) {
+        if (!req.user) {
+            return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
+        }
+        return req.Inertia.render({
+            component: 'notification',
+            props: {
+                title: req.i18n.__('Notifications'),
+            }
+        });
+    }
+    // Единый SSE endpoint для всех уведомлений
+    static async getNotificationsStream(req, res) {
+        NotificationController.checkPermission(req, res);
+        // Устанавливаем заголовки для SSE
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.flushHeaders();
+        const clientId = `user-${req.user?.id}-${Date.now()}`;
+        // Функция для отправки событий клиенту
+        const sendEvent = (event) => {
+            // Фильтруем уведомления по правам пользователя
+            if (event.type === 'notification') {
+                // Системные уведомления только для админов
+                if (event.notificationClass === 'system' && !NotificationController.isAdmin(req.user)) {
+                    return;
+                }
+                if (event.userId !== null && event.userId !== req.user.id) {
+                    return;
+                }
+            }
+            res.write(`event: ${event.type}\n`);
+            res.write(`data: ${JSON.stringify(event.data)}\n\n`);
+        };
+        // Подключаем клиента ко всем сервисам
+        const services = req.adminizer.notificationHandler.getAllServices();
+        services.forEach(service => {
+            service.addClient(clientId, sendEvent);
+            // Для системного сервиса добавляем клиента в CRUD каналы
+            if (service.notificationClass === 'system' && NotificationController.isAdmin(req.user)) {
+                const systemService = service;
+                // Добавляем клиента в основные CRUD каналы
+                ['created', 'updated', 'deleted', 'system'].forEach(channel => {
+                    systemService.addClientToChannel(clientId, channel);
+                });
+            }
+        });
+        // Отправляем приветственное сообщение
+        sendEvent({
+            type: 'connected',
+            data: {
+                message: 'Connected to unified notification stream',
+                clientId: clientId
+            }
+        });
+        // Отправляем историю уведомлений (с учетом прав доступа)
+        // try {
+        //     const notifications = await req.adminizer.notificationHandler.getUserNotifications(
+        //         req.user,
+        //         4,
+        //         true
+        //     );
+        //     notifications.forEach(notification => {
+        //         sendEvent({
+        //             type: 'notification',
+        //             data: notification,
+        //             notificationClass: notification.notificationClass,
+        //             userId: notification.userId ?? null
+        //         });
+        //     });
+        // } catch (error) {
+        //     Adminizer.log.error('Error sending notification history:', error);
+        // }
+        // Обработка закрытия соединения
+        req.on('close', () => {
+            // Отключаем клиента от всех сервисов
+            services.forEach(service => {
+                service.removeClient(clientId);
+                // Для системного сервиса удаляем из всех каналов
+                if (service.notificationClass === 'system') {
+                    const systemService = service;
+                    if (systemService.removeClientFromAllChannels) {
+                        systemService.removeClientFromAllChannels(clientId);
+                    }
+                }
+            });
+            res.end();
+        });
+        // Heartbeat для поддержания соединения
+        const heartbeatInterval = setInterval(() => {
+            if (!res.writableEnded) {
+                services.forEach(service => {
+                    service.sendHeartbeat(clientId);
+                });
+            }
+            else {
+                clearInterval(heartbeatInterval);
+            }
+        }, 30000);
+        req.on('close', () => {
+            clearInterval(heartbeatInterval);
+        });
+    }
+    // API для получения уведомлений по классу
+    static async getNotificationsByClass(req, res) {
+        NotificationController.checkPermission(req, res);
+        try {
+            const { notificationClass } = req.params;
+            const { limit = 50, unreadOnly = false } = req.query;
+            // Проверяем права доступа для системных уведомлений
+            if (notificationClass === 'system' && !NotificationController.isAdmin(req.user)) {
+                res.status(403).json({ error: 'Forbidden: Admin access required' });
+                return;
+            }
+            const notifications = await req.adminizer.notificationHandler.getNotifications(notificationClass, req.user?.id, Number(limit), unreadOnly === 'true');
+            res.json(notifications);
+        }
+        catch (error) {
+            Adminizer.log.error('Error getting notifications:', error);
+            res.status(500).json({ error: 'Internal server error' });
+        }
+    }
+    // API для получения всех уведомлений пользователя
+    static async getUserNotifications(req, res) {
+        NotificationController.checkPermission(req, res);
+        try {
+            const notifications = await req.adminizer.notificationHandler.getUserNotifications(req.user, 4, true);
+            res.json(notifications);
+        }
+        catch (error) {
+            Adminizer.log.error('Error getting user notifications:', error);
+            res.status(500).json({ error: 'Internal server error' });
+        }
+    }
+    static async getAllUserNotifications(req, res) {
+        NotificationController.checkPermission(req, res);
+        try {
+            const notifications = await req.adminizer.notificationHandler.getUserNotifications(req.user, 50, false);
+            res.json(notifications);
+        }
+        catch (error) {
+            Adminizer.log.error('Error getting user notifications:', error);
+            res.status(500).json({ error: 'Internal server error' });
+        }
+    }
+    // API для пометки как прочитанного
+    static async markAsRead(req, res) {
+        NotificationController.checkPermission(req, res);
+        try {
+            const { notificationClass, id } = req.params;
+            // Проверяем права доступа для системных уведомлений
+            if (notificationClass === 'system' && !NotificationController.isAdmin(req.user)) {
+                res.status(403).json({ error: 'Forbidden: Admin access required' });
+                return;
+            }
+            await req.adminizer.notificationHandler.markAsRead(notificationClass, id, req.user.id);
+            res.json({ success: true });
+        }
+        catch (error) {
+            Adminizer.log.error('Error marking notification as read:', error);
+            res.status(500).json({ error: 'Internal server error' });
+        }
+    }
+    // API для отправки уведомления
+    static async sendNotification(req, res) {
+        NotificationController.checkPermission(req, res);
+        // Проверяем права админа
+        if (!NotificationController.isAdmin(req.user)) {
+            res.status(403).json({ error: 'Forbidden: Admin access required' });
+            return;
+        }
+        try {
+            const { title, message, type, priority, userId, channel, notificationClass = 'general' } = req.body;
+            const notificationId = await req.adminizer.notificationHandler.dispatchNotification(notificationClass, { title, message, userId, channel });
+            res.json({ success: true, id: notificationId });
+        }
+        catch (error) {
+            Adminizer.log.error('Error sending notification:', error);
+            res.status(500).json({ error: 'Internal server error' });
+        }
+    }
+    // Проверка прав администратора
+    static isAdmin(user) {
+        if (!user)
+            return false;
+        return user.isAdministrator === true;
+    }
+    static checkPermission(req, res) {
+        if (!req.adminizer?.notificationHandler) {
+            res.status(500).json({ error: 'Notification system not initialized' });
+            return;
+        }
+        // Проверяем аутентификацию
+        if (req.adminizer.config.auth.enable && !req.user) {
+            res.status(401).json({ error: 'Unauthorized' });
+            return;
+        }
+    }
+}

package/controllers/remove.js

@@ -67,6 +67,8 @@ export default async function remove(req, res) {
         Adminizer.log.error('adminpanel > error', e);
     }
     if (destroyedRecord) {
+        // log system event notification
+        await req.adminizer.logSystemDeletedEvent(req.i18n.__('Deleted'), `user ${req.user.login} ${req.i18n.__('delete')} ${entity.name} ${destroyedRecord[0].id}`, { test: 'test' });
         req.flash.setFlashMessage('success', req.i18n.__('Record was removed successfully !'));
     }
     else {

package/helpers/diffHelpers.d.ts

@@ -0,0 +1,2 @@
+export declare function sanitizeForDiff(data: any): any;
+export declare function formatChanges(diffObj: any, oldData: any, newData: any): any[];

package/helpers/diffHelpers.js

@@ -0,0 +1,24 @@
+export function sanitizeForDiff(data) {
+    if (!data)
+        return {};
+    const result = { ...data };
+    // Удаляем системные поля
+    const systemFields = ['id', 'createdAt', 'updatedAt', 'deletedAt', '__v', '_id'];
+    systemFields.forEach(field => delete result[field]);
+    // Очищаем чувствительные данные
+    const sensitiveFields = ['password', 'token', 'secret', 'apiKey', 'creditCard'];
+    sensitiveFields.forEach(field => {
+        if (result[field] !== undefined) {
+            result[field] = '***HIDDEN***';
+        }
+    });
+    return result;
+}
+export function formatChanges(diffObj, oldData, newData) {
+    return Object.entries(diffObj).map(([key, value]) => ({
+        field: key,
+        oldValue: oldData[key],
+        newValue: newData[key],
+        type: typeof value
+    }));
+}

package/helpers/inertiaAutHelper.js

@@ -11,6 +11,25 @@ export function inertiaLoginHelper(req) {
             link: `${req.adminizer.config.routePrefix}/model/userap/register`
         };
     }
+    // Optional additional link at the bottom of login page
+    const addPage = req.adminizer.config.auth?.addishinalLoginPage;
+    if (addPage && typeof addPage.link === 'string' && addPage.link.length > 0) {
+        const raw = addPage.link;
+        let link = raw;
+        if (/^https?:\/\//i.test(raw)) {
+            link = raw; // absolute URL
+        }
+        else if (raw.startsWith(`/${req.adminizer.config.routePrefix}`)) {
+            link = `${raw}`;
+        }
+        else {
+            link = `${req.adminizer.config.routePrefix}/${raw}`;
+        }
+        props.addishinalLoginPage = {
+            title: req.i18n.__(addPage.textKey || 'Additional login page'),
+            link,
+        };
+    }
     return props;
 }
 export function inertiaRegisterHelper(req) {

package/index.d.ts

@@ -12,6 +12,8 @@ export * from "./lib/v4/catalog/Navigation";
 export * from "./lib/v4/catalog/CatalogHandler";
 export * from "./lib/media-manager/MediaManagerHandler";
 export * from "./interfaces/adminpanelConfig";
+export * from "./interfaces/types";
+export * from "./interfaces/MaaterialIcons";
 export * from "./lib/v4/model/AbstractModel";
 export * from "./lib/v4/model/adapter/waterline";
 export * from "./lib/v4/model/adapter/typeorm";

package/index.js

@@ -12,6 +12,8 @@ export * from "./lib/v4/catalog/Navigation";
 export * from "./lib/v4/catalog/CatalogHandler";
 export * from "./lib/media-manager/MediaManagerHandler";
 export * from "./interfaces/adminpanelConfig";
+export * from "./interfaces/types";
+export * from "./interfaces/MaaterialIcons";
 export * from "./lib/v4/model/AbstractModel";
 export * from "./lib/v4/model/adapter/waterline";
 export * from "./lib/v4/model/adapter/typeorm";

package/interfaces/adminpanelConfig.d.ts

@@ -36,6 +36,18 @@ export interface AdminpanelConfig {
         captcha?: boolean;
         /** Description displayed on login page */
         description?: string;
+        /**
+         * Optional additional link at the bottom of the login page
+         * Example:
+         *  addishinalLoginPage: { link: '/model/userap/register', textKey: 'Additional login page' }
+         *  link can be relative to routePrefix (e.g. 'model/help' or '/model/help') or absolute (https://...)
+         */
+        addishinalLoginPage?: {
+            /** Target URL; relative to routePrefix unless absolute */
+            link: string;
+            /** Optional i18n key for label; defaults to 'Additional login page' */
+            textKey?: string;
+        };
     };
     /**
      * @alpha
@@ -173,6 +185,12 @@ export interface AdminpanelConfig {
         /** Default ORM adapter for system models */
         defaultORM: string;
     };
+    bind?: {
+        public: boolean;
+    };
+    notification?: {
+        enabled: boolean;
+    };
 }
 export interface ModelConfig {
     adapter?: string;

package/interfaces/types.d.ts

@@ -25,3 +25,25 @@ export interface PropsField {
     isIn?: string[] | number[] | boolean[];
     options?: Record<string, unknown> | Record<string, unknown>[];
 }
+export interface INotification {
+    id: string;
+    title: string;
+    message: string;
+    createdAt: Date;
+    userId?: number;
+    read?: boolean;
+    icon: {
+        icon: string;
+        iconColor: string;
+    };
+    notificationClass: string;
+    channel: string;
+    metadata?: Record<string | number, any>;
+}
+export interface INotificationEvent {
+    type: 'notification' | 'heartbeat' | 'connected' | 'error';
+    data: INotification | string;
+    notificationClass?: string;
+    channel?: string;
+    userId?: number;
+}

package/lib/Adminizer.d.ts

@@ -1,4 +1,4 @@
-import { Express } from "express";
+import express, { Express } from "express";
 import winston from "winston";
 import EventEmitter from 'events';
 import { AdminpanelConfig } from "../interfaces/adminpanelConfig";
@@ -12,6 +12,10 @@ import type { ViteDevServer } from 'vite';
 import { MenuHelper } from "../helpers/menuHelper";
 import { ControlsHandler } from "./v4/controls/ControlsHandler";
 import { CatalogHandler } from "./v4/catalog/CatalogHandler";
+import { NotificationHandler } from './v4/notifications/NotificationHandler';
+import { INotification } from "../interfaces/types";
+import { UserAP } from "models/UserAP";
+export type AuthHandler = (req: ReqType, login: string, password: string) => Promise<Partial<UserAP> | null>;
 export declare class Adminizer {
     /**
      * If you convey this default Middleware, it will add it to the very top of the router,
@@ -26,21 +30,33 @@ export declare class Adminizer {
     accessRightsHelper: AccessRightsHelper;
     configHelper: ConfigHelper;
     menuHelper: MenuHelper;
+    notificationHandler: NotificationHandler;
     modelHandler: ModelHandler;
     widgetHandler: WidgetHandler;
     vite: ViteDevServer;
     controlsHandler: ControlsHandler;
     catalogHandler: CatalogHandler;
     jwtSecret: string;
+    authHandler?: AuthHandler;
     static logger: winston.Logger;
     constructor(ormAdapters: AbstractAdapter[]);
-    getMiddleware(): (req: any, res: any) => void;
+    /**
+     * 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: AuthHandler): void;
+    getMiddleware(): (req: express.Request, res: express.Response, next: () => void) => void;
     /**
      * Vite middleware
      * @protected
      */
     protected viteMiddleware(): Promise<void>;
     init(config: AdminpanelConfig): Promise<void>;
+    sendNotification(notification: Omit<INotification, 'id' | 'createdAt' | 'icon'>): Promise<boolean>;
+    logSystemEvent(title: string, message: string, metadata?: any): Promise<boolean>;
+    logSystemCreatedEvent(title: string, message: string, metadata?: any): Promise<boolean>;
+    logSystemUpdatedEvent(title: string, message: string, metadata?: any): Promise<boolean>;
+    logSystemDeletedEvent(title: string, message: string, metadata?: any): Promise<boolean>;
     get emitter(): EventEmitter;
     getOrmAdapter(ormType: string): AbstractAdapter;
     static get log(): {