adminizer 4.2.0 → 4.3.0-build.100

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;

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

@@ -1,5 +1,5 @@
 import { BaseWidget } from "./abstractWidgetBase";
-import { MaterialIcon } from "../../../interfaces/MaaterialIcons";
+import { MaterialIcon } from "../../interfaces/MaaterialIcons";
 export interface Links {
     name: string;
     description: string;

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

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

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

@@ -3,8 +3,8 @@ import { InfoBase } from "./abstractInfo";
 import { ActionBase } from "./abstractAction";
 import { LinkBase } from "./abstractLink";
 import { CustomBase } from "./abstractCustom";
-import { AdminpanelIcon } from "../../../interfaces/adminpanelConfig";
-import { Adminizer } from "../../Adminizer";
+import { AdminpanelIcon } from "../../interfaces/adminpanelConfig";
+import { Adminizer } from "../Adminizer";
 import { UserAP } from "models/UserAP";
 import { I18n } from "../I18n";
 export type WidgetType = (SwitchBase | InfoBase | ActionBase | LinkBase | CustomBase);

package/migrations/index.d.ts

@@ -0,0 +1,3 @@
+export declare const migrations: {
+    umzug: import("..").Migration[];
+};

package/migrations/index.js

@@ -0,0 +1,4 @@
+import { umzugExports } from "./umzugExports";
+export const migrations = {
+    umzug: umzugExports
+};

package/migrations/umzug/0001.d.ts

@@ -0,0 +1,7 @@
+import { QueryInterface } from "sequelize";
+type Ctx = {
+    context: QueryInterface;
+};
+export declare function up({ context }: Ctx): Promise<void>;
+export declare function down({ context }: Ctx): Promise<void>;
+export {};

package/migrations/umzug/0001.js

@@ -0,0 +1,121 @@
+import { DataTypes } from "sequelize";
+// Creates all system model tables according to src/models/* and
+// SequelizeAdapter.generateSequelizeModel naming: tableName = modelName.toLowerCase()
+// Associations:
+// - UserAP <-> GroupAP: M:N via through table "groupapuserap" (UserAPId, GroupAPId)
+// - MediaManagerAP.parent -> MediaManagerAP (parentId)
+// - MediaManagerAP hasMany MediaManagerMetaAP via parent (MediaManagerMetaAP.parentId)
+// - MediaManagerAP hasMany MediaManagerAssociationsAP via file (MediaManagerAssociationsAP.fileId)
+// - UserNotificationAP belongsTo NotificationAP via alias "notificationId" -> FK column "notificationIdId"
+export async function up({ context }) {
+    // userap
+    await context.createTable("userap", {
+        id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
+        login: { type: DataTypes.STRING, unique: true },
+        fullName: { type: DataTypes.STRING },
+        email: { type: DataTypes.STRING },
+        avatar: { type: DataTypes.STRING },
+        passwordHashed: { type: DataTypes.STRING },
+        timezone: { type: DataTypes.STRING },
+        expires: { type: DataTypes.STRING },
+        locale: { type: DataTypes.STRING },
+        isDeleted: { type: DataTypes.BOOLEAN },
+        isActive: { type: DataTypes.BOOLEAN },
+        isAdministrator: { type: DataTypes.BOOLEAN },
+        widgets: { type: DataTypes.JSON },
+        isConfirmed: { type: DataTypes.BOOLEAN },
+        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    });
+    // groupap
+    await context.createTable("groupap", {
+        id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
+        name: { type: DataTypes.STRING, unique: true },
+        description: { type: DataTypes.STRING },
+        tokens: { type: DataTypes.JSON },
+        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    });
+    // mediamanagerap (self-ref via parentId)
+    await context.createTable("mediamanagerap", {
+        id: { type: DataTypes.UUID, defaultValue: DataTypes.UUIDV4, primaryKey: true, allowNull: false },
+        parentId: { type: DataTypes.UUID, allowNull: true, references: { model: "mediamanagerap", key: "id" } },
+        mimeType: { type: DataTypes.STRING },
+        path: { type: DataTypes.STRING },
+        size: { type: DataTypes.INTEGER },
+        group: { type: DataTypes.STRING },
+        tag: { type: DataTypes.STRING },
+        url: { type: DataTypes.STRING },
+        filename: { type: DataTypes.STRING },
+        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    });
+    // mediamanagermetaap (belongsTo mediamanagerap via parentId)
+    await context.createTable("mediamanagermetaap", {
+        id: { type: DataTypes.UUID, defaultValue: DataTypes.UUIDV4, primaryKey: true, allowNull: false },
+        key: { type: DataTypes.STRING },
+        value: { type: DataTypes.JSON },
+        isPublic: { type: DataTypes.BOOLEAN },
+        parentId: { type: DataTypes.UUID, allowNull: true, references: { model: "mediamanagerap", key: "id" } },
+        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    });
+    // mediamanagerassociationsap (belongsTo mediamanagerap via fileId)
+    await context.createTable("mediamanagerassociationsap", {
+        id: { type: DataTypes.UUID, defaultValue: DataTypes.UUIDV4, primaryKey: true, allowNull: false },
+        mediaManagerId: { type: DataTypes.STRING },
+        model: { type: DataTypes.JSON },
+        modelId: { type: DataTypes.JSON },
+        widgetName: { type: DataTypes.STRING },
+        sortOrder: { type: DataTypes.INTEGER },
+        fileId: { type: DataTypes.UUID, allowNull: true, references: { model: "mediamanagerap", key: "id" } },
+        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    });
+    // notificationap
+    await context.createTable("notificationap", {
+        id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
+        title: { type: DataTypes.STRING },
+        message: { type: DataTypes.STRING },
+        notificationClass: { type: DataTypes.STRING },
+        channel: { type: DataTypes.STRING },
+        metadata: { type: DataTypes.JSON },
+        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    });
+    // usernotificationap (FK to notificationap via column notificationIdId)
+    await context.createTable("usernotificationap", {
+        id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
+        userId: { type: DataTypes.INTEGER },
+        notificationIdId: { type: DataTypes.INTEGER, allowNull: true, references: { model: "notificationap", key: "id" } },
+        read: { type: DataTypes.BOOLEAN },
+        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    });
+    // navigationap
+    await context.createTable("navigationap", {
+        id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
+        label: { type: DataTypes.STRING, unique: true },
+        tree: { type: DataTypes.JSON },
+        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    });
+    // M:N join: GroupAP <-> UserAP via "groupapuserap"
+    await context.createTable("groupapuserap", {
+        UserAPId: { type: DataTypes.INTEGER, allowNull: false, references: { model: "userap", key: "id" } },
+        GroupAPId: { type: DataTypes.INTEGER, allowNull: false, references: { model: "groupap", key: "id" } },
+        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
+    });
+}
+export async function down({ context }) {
+    await context.dropTable("groupapuserap");
+    await context.dropTable("usernotificationap");
+    await context.dropTable("mediamanagermetaap");
+    await context.dropTable("mediamanagerassociationsap");
+    await context.dropTable("mediamanagerap");
+    await context.dropTable("navigationap");
+    await context.dropTable("notificationap");
+    await context.dropTable("groupap");
+    await context.dropTable("userap");
+}

package/migrations/umzugExports.d.ts

@@ -0,0 +1,2 @@
+import { Migration } from "interfaces/types";
+export declare const umzugExports: Migration[];

package/migrations/umzugExports.js

@@ -0,0 +1,9 @@
+import { up as up0001, down as down0001 } from "./umzug/0001";
+export const umzugExports = [
+    {
+        name: "0001",
+        timestamp: 1757930548596,
+        up: up0001,
+        down: down0001
+    }
+];

package/models/MediaManagerAP.d.ts

@@ -3,10 +3,8 @@ import { MediaManagerMetaAP } from "./MediaManagerMetaAP";
 declare const _default: {
     id: {
         type: string;
-        allowNull: boolean;
-        uuid: boolean;
+        autoIncrement: boolean;
         primaryKey: boolean;
-        required: boolean;
     };
     parent: {
         model: string;
@@ -44,6 +42,14 @@ declare const _default: {
         collection: string;
         via: string;
     };
+    createdAt: {
+        type: string;
+        autoCreatedAt: boolean;
+    };
+    updatedAt: {
+        type: string;
+        autoUpdatedAt: boolean;
+    };
 };
 export default _default;
 export interface MediaManagerAP {

package/models/MediaManagerAP.js

@@ -1,10 +1,8 @@
 export default {
     id: {
-        type: "string",
-        allowNull: false,
-        uuid: true,
-        primaryKey: true,
-        required: true
+        type: "number",
+        autoIncrement: true,
+        primaryKey: true
     },
     parent: {
         model: "MediaManagerAP"
@@ -41,5 +39,13 @@ export default {
     modelAssociation: {
         collection: "MediaManagerAssociationsAP",
         via: "file"
+    },
+    createdAt: {
+        type: 'number',
+        autoCreatedAt: true
+    },
+    updatedAt: {
+        type: 'number',
+        autoUpdatedAt: true
     }
 };

package/models/MediaManagerAssociationsAP.d.ts

@@ -2,10 +2,8 @@ import { MediaManagerAP } from "./MediaManagerAP";
 declare const _default: {
     id: {
         type: string;
-        allowNull: boolean;
-        uuid: boolean;
+        autoIncrement: boolean;
         primaryKey: boolean;
-        required: boolean;
     };
     mediaManagerId: {
         type: string;
@@ -25,6 +23,14 @@ declare const _default: {
     file: {
         model: string;
     };
+    createdAt: {
+        type: string;
+        autoCreatedAt: boolean;
+    };
+    updatedAt: {
+        type: string;
+        autoUpdatedAt: boolean;
+    };
 };
 export default _default;
 export interface MediaManagerAssociationsAP {

package/models/MediaManagerAssociationsAP.js

@@ -1,10 +1,8 @@
 export default {
     id: {
-        type: "string",
-        allowNull: false,
-        uuid: true,
-        primaryKey: true,
-        required: true
+        type: "number",
+        autoIncrement: true,
+        primaryKey: true
     },
     mediaManagerId: {
         type: "string"
@@ -23,5 +21,13 @@ export default {
     },
     file: {
         model: "MediaManagerAP"
+    },
+    createdAt: {
+        type: 'number',
+        autoCreatedAt: true
+    },
+    updatedAt: {
+        type: 'number',
+        autoUpdatedAt: true
     }
 };

package/models/MediaManagerMetaAP.d.ts

@@ -2,10 +2,8 @@ import { MediaManagerAP } from "./MediaManagerAP";
 declare const _default: {
     id: {
         type: string;
-        allowNull: boolean;
-        uuid: boolean;
+        autoIncrement: boolean;
         primaryKey: boolean;
-        required: boolean;
     };
     key: {
         type: string;
@@ -19,6 +17,14 @@ declare const _default: {
     parent: {
         model: string;
     };
+    createdAt: {
+        type: string;
+        autoCreatedAt: boolean;
+    };
+    updatedAt: {
+        type: string;
+        autoUpdatedAt: boolean;
+    };
 };
 export default _default;
 export interface MediaManagerMetaAP {

package/models/MediaManagerMetaAP.js

@@ -1,10 +1,8 @@
 export default {
     id: {
-        type: "string",
-        allowNull: false,
-        uuid: true,
-        primaryKey: true,
-        required: true
+        type: "number",
+        autoIncrement: true,
+        primaryKey: true
     },
     key: {
         type: "string"
@@ -17,5 +15,13 @@ export default {
     },
     parent: {
         model: "MediaManagerAP"
+    },
+    createdAt: {
+        type: 'number',
+        autoCreatedAt: true
+    },
+    updatedAt: {
+        type: 'number',
+        autoUpdatedAt: true
     }
 };

package/models/NotificationAP.d.ts

@@ -0,0 +1,44 @@
+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;
+    };
+    createdAt: {
+        type: string;
+        autoCreatedAt: boolean;
+    };
+    updatedAt: {
+        type: string;
+        autoUpdatedAt: boolean;
+    };
+};
+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;
+}

package/models/NotificationAP.js

@@ -0,0 +1,30 @@
+export default {
+    id: {
+        type: "number",
+        autoIncrement: true,
+        primaryKey: true
+    },
+    title: {
+        type: "string"
+    },
+    message: {
+        type: "string"
+    },
+    notificationClass: {
+        type: "string",
+    },
+    channel: {
+        type: "string",
+    },
+    metadata: {
+        type: 'json'
+    },
+    createdAt: {
+        type: 'number',
+        autoCreatedAt: true
+    },
+    updatedAt: {
+        type: 'number',
+        autoUpdatedAt: true
+    }
+};

package/models/UserAP.d.ts

@@ -1,4 +1,4 @@
-import { WidgetConfig, WidgetsLayouts } from "lib/v4/widgets/widgetHandler";
+import { WidgetConfig, WidgetsLayouts } from "lib/widgets/widgetHandler";
 import { GroupAP } from "./GroupAP";
 declare const _default: {
     id: {

package/models/UserNotificationAP.d.ts

@@ -0,0 +1,26 @@
+import { NotificationAP } from "./NotificationAP";
+declare const _default: {
+    id: {
+        type: string;
+        autoIncrement: boolean;
+        primaryKey: boolean;
+    };
+    userId: {
+        type: string;
+        required: boolean;
+    };
+    notificationId: {
+        model: string;
+    };
+    read: {
+        type: string;
+        defaultsTo: boolean;
+    };
+};
+export default _default;
+export interface UserNotificationAP {
+    id: number;
+    userId: number;
+    notificationId: NotificationAP;
+    read: boolean;
+}

package/models/UserNotificationAP.js

@@ -0,0 +1,18 @@
+export default {
+    id: {
+        type: "number",
+        autoIncrement: true,
+        primaryKey: true
+    },
+    userId: {
+        type: "number",
+        required: true
+    },
+    notificationId: {
+        model: "NotificationAP"
+    },
+    read: {
+        type: "boolean",
+        defaultsTo: false
+    }
+};