adminizer 4.1.0-commit.d8a06d3 → 4.2.0-build.44

package/controllers/catalog/Catalog.js

@@ -1,4 +1,4 @@
-import { CatalogHandler } from "../../lib/catalog/CatalogHandler";
+import { CatalogHandler } from "../../lib/v4/catalog/CatalogHandler";
 import { VueCatalog } from "./FrontentCatalogAdapter";
 import { Adminizer } from "../../lib/Adminizer";
 export async function catalogController(req, res) {
@@ -28,64 +28,69 @@ export async function catalogController(req, res) {
     }
     const method = req.method.toUpperCase();
     if (method === 'GET') {
-        return res.viewAdmin('catalog', { entity: "entity", slug: slug, id: id });
+        return req.Inertia.render({
+            component: 'catalog',
+            props: null
+        });
     }
     if (method === 'POST' || method === 'PUT' || method === 'DELETE') {
         const data = req.body;
-        const vueCatalog = new VueCatalog(_catalog);
-        if (!vueCatalog)
+        const frontendCatalog = new VueCatalog(_catalog);
+        if (!frontendCatalog)
             return res.status(404);
-        vueCatalog.setId(id);
-        const item = vueCatalog.getItemType(data.type);
+        frontendCatalog.setId(id);
+        const item = frontendCatalog.getItemType(data.type);
         switch (method) {
             case 'POST':
                 switch (data._method) {
-                    case 'getAddHTML':
-                        return res.json(await vueCatalog.getAddHTML(item, req));
-                    case 'getEditHTML':
-                        return res.json(await vueCatalog.getEditHTML(item, data.id, req, data.modelId));
+                    case 'getAddTemplate':
+                        return res.json(await frontendCatalog.getAddTemplate(item, req));
+                    case 'getEditTemplate':
+                        return res.json(await frontendCatalog.getEditTemplate(item, data.id, req, data.modelId));
                     case 'getCatalog':
-                        const __catalog = await vueCatalog.getCatalog();
-                        return res.json({
-                            'items': vueCatalog.getitemTypes(),
-                            'catalog': {
-                                nodes: __catalog,
-                                movingGroupsRootOnly: _catalog.movingGroupsRootOnly ?? false,
-                                catalogName: _catalog.name,
-                                catalogId: _catalog.id,
-                                catalogSlug: _catalog.slug,
-                                idList: idList
-                            },
-                            'toolsActions': await vueCatalog.getActions([], 'tools')
-                        });
+                        {
+                            const __catalog = await frontendCatalog.getCatalog();
+                            return res.json({
+                                items: frontendCatalog.getitemTypes(),
+                                catalog: {
+                                    nodes: __catalog,
+                                    movingGroupsRootOnly: _catalog.movingGroupsRootOnly ?? false,
+                                    catalogName: _catalog.name,
+                                    catalogId: _catalog.id,
+                                    catalogSlug: _catalog.slug,
+                                    idList: idList
+                                },
+                                toolsActions: await frontendCatalog.getActions([], 'tools')
+                            });
+                        }
                     case 'createItem':
-                        return res.json({ 'data': await vueCatalog.createItem(data.data) });
+                        return res.json({ 'data': await frontendCatalog.createItem(data.data, req) });
                     case 'getChilds':
-                        return res.json({ data: await vueCatalog.getChilds(data.data) });
+                        return res.json({ data: await frontendCatalog.getChilds(data.data, req) });
                     case 'getActions':
-                        return res.json({ data: await vueCatalog.getActions(data.items, data.type) });
+                        return res.json({ data: await frontendCatalog.getActions(data.items, data.type) });
                     case 'search':
-                        return res.json({ data: await vueCatalog.search(data.s) });
+                        return res.json({ data: await frontendCatalog.search(data.s, req) });
                     case "getLocales":
-                        return res.json({ data: vueCatalog.getLocales(req) });
+                        return res.json({ data: frontendCatalog.getLocales(req) });
                 }
                 break;
             case 'PUT':
                 switch (data._method) {
                     case 'updateTree':
-                        return res.json({ data: await vueCatalog.updateTree(data.data) });
+                        return res.json({ data: await frontendCatalog.updateTree(data.data, req) });
                     case 'getLink':
-                        return res.json({ data: await vueCatalog.getLink(data.actionId) });
+                        return res.json({ data: await frontendCatalog.getLink(data.actionId) });
                     case 'handleAction':
-                        return res.json({ data: await vueCatalog.handleAction(data.data.actionID, data.data.items, data.data.config) });
-                    case 'getPopUpHTML':
-                        return res.json({ data: await vueCatalog.getPopUpHTML(data.actionId) });
+                        return res.json({ data: await frontendCatalog.handleAction(data.data.actionID, data.data.items, data.data.data, req) });
+                    case 'getPopUpTemplate':
+                        return res.json({ data: await frontendCatalog.getPopUpTemplate(data.actionId, req) });
                     case 'updateItem':
-                        return res.json({ data: await vueCatalog.updateItem(item, data.modelId, data.data) });
+                        return res.json({ data: await frontendCatalog.updateItem(item, data.modelId, data.data, req) });
                 }
                 break;
             case 'DELETE':
-                return res.json({ data: await vueCatalog.deleteItem(data.data) });
+                return res.json({ data: await frontendCatalog.deleteItem(data.data, req) });
         }
     }
 }

package/controllers/catalog/FrontentCatalogAdapter.d.ts

@@ -1,9 +1,9 @@
-import { AbstractCatalog, Item } from "../../lib/catalog/AbstractCatalog";
+import { AbstractCatalog, Item } from "../../lib/v4/catalog/AbstractCatalog";
 interface NodeModel<TDataType> {
-    title: string;
-    isLeaf: boolean;
-    isExpanded: boolean;
-    ind: number;
+    text: string;
+    droppable: boolean;
+    id: string;
+    parent: string;
     data?: TDataType;
     children?: NodeModel<TDataType>[];
     isSelected?: boolean;
@@ -18,40 +18,50 @@ interface NodeModel<TDataType> {
 }
 interface NodeData extends Item {
 }
-interface obj {
-    [key: string]: string;
-}
 interface RequestData {
     reqNode: NodeModel<NodeData>[];
     reqParent: NodeModel<NodeData>;
     _method: string;
 }
+/**
+ * @deprecated Now is React
+ * // TODO: refactor for react name
+ */
 export declare class VueCatalog {
     catalog: AbstractCatalog;
     constructor(_catalog: AbstractCatalog);
     setId(id: string): void;
-    getItemType(type: string): import("../../lib/catalog/AbstractCatalog").BaseItem<Item>;
-    getAddHTML(item: any, req: ReqType): Promise<{
-        type: "link" | "html" | "jsonForm";
-        data: string;
+    getItemType(type: string): import("../../lib/v4/catalog/AbstractCatalog").BaseItem<Item>;
+    getAddTemplate(item: any, req: ReqType): Promise<{
+        type: "component" | "navigation.group" | "navigation.link" | "model";
+        data: any;
     }>;
-    getEditHTML(item: any, id: string | number, req: ReqType, modelId: string | number): Promise<{
-        type: "link" | "html" | "jsonForm";
-        data: string;
+    getEditTemplate(item: any, id: string | number, req: ReqType, modelId: string | number): Promise<{
+        type: "component" | "navigation.group" | "navigation.link" | "model";
+        data: any;
     }>;
-    getitemTypes(): import("../../lib/catalog/AbstractCatalog").BaseItem<Item>[];
-    getLocales(req: ReqType): obj;
-    getActions(items: NodeModel<any>[], type: string): Promise<import("../../lib/catalog/AbstractCatalog").ActionHandler[]>;
-    handleAction(actionId: string, items: any[], config: any): Promise<void>;
-    getPopUpHTML(actionId: string): Promise<string>;
+    getitemTypes(): {
+        type: string;
+        name: string;
+        isGroup: boolean;
+        allowedRoot: boolean;
+        icon: string;
+        actionHandlers: import("../../lib/v4/catalog/AbstractCatalog").ActionHandler[];
+    }[];
+    getLocales(req: ReqType): {
+        [key: string]: string;
+    };
+    getActions(items: NodeModel<any>[], type: string): Promise<import("../../lib/v4/catalog/AbstractCatalog").ActionHandler[]>;
+    handleAction(actionId: string, items: any[], data: any, req: ReqType): Promise<string | void>;
+    getPopUpTemplate(actionId: string, req: ReqType): Promise<string>;
     getLink(actionId: string): Promise<string>;
     getCatalog(): Promise<NodeModel<Item>[]>;
-    createItem(data: any): Promise<any>;
-    getChilds(data: any): Promise<NodeModel<Item>[]>;
-    search(s: string): Promise<NodeModel<Item>[]>;
-    updateTree(data: RequestData): Promise<any>;
-    updateItem(item: any, modelId: string, data: any): Promise<any>;
-    deleteItem(items: NodeModel<any>[]): Promise<{
+    createItem(data: any, req: ReqType): Promise<any>;
+    getChilds(data: any, req: ReqType): Promise<NodeModel<Item>[]>;
+    search(s: string, req: ReqType): Promise<NodeModel<Item>[]>;
+    updateTree(data: RequestData, req: ReqType): Promise<any>;
+    updateItem(item: any, modelId: string, data: any, req: ReqType): Promise<any>;
+    deleteItem(item: Item, req: ReqType): Promise<{
         ok: boolean;
     }>;
 }

package/controllers/catalog/FrontentCatalogAdapter.js

@@ -1,4 +1,7 @@
-import { AbstractCatalog } from "../../lib/catalog/AbstractCatalog";
+/**
+ * @deprecated Now is React
+ * // TODO: refactor for react name
+ */
 export class VueCatalog {
     catalog;
     constructor(_catalog) {
@@ -10,11 +13,11 @@ export class VueCatalog {
     getItemType(type) {
         return this.catalog.getItemType(type);
     }
-    getAddHTML(item, req) {
-        return this.catalog.getAddHTML(item, req);
+    getAddTemplate(item, req) {
+        return this.catalog.getAddTemplate(item, req);
     }
-    getEditHTML(item, id, req, modelId) {
-        return this.catalog.getEditHTML(item, id, req, modelId);
+    getEditTemplate(item, id, req, modelId) {
+        return this.catalog.getEditTemplate(item, id, req, modelId);
     }
     getitemTypes() {
         return this.catalog.getitemTypes();
@@ -28,28 +31,35 @@ export class VueCatalog {
             "Select Item type": "",
             "Select Items": "",
             "Save": "",
-            "No, cancel": "",
+            "No": "",
             "Are you sure?": "",
-            "Yes, I'm sure": "",
-            "Select Ids": ""
+            "Yes": "",
+            "Select Ids": "",
+            "OR": "",
+            "Open in a new window": "",
+            "Clean": "",
+            "Performing an action...": "",
+            "Action completed": "",
         };
         obj[this.catalog.name] = "";
         for (const actionHandler of this.catalog.actionHandlers) {
             obj[actionHandler.name] = "";
         }
         let messages = obj;
-        req.i18n.setLocale(req.user.locale);
         let outMessages = {};
         for (const mess of Object.keys(messages)) {
             outMessages[mess] = req.i18n.__(mess);
         }
-        return outMessages;
+        return {
+            ...outMessages,
+        };
     }
     async getActions(items, type) {
         let arrItems = [];
         for (const item of items) {
             arrItems.push(await this.catalog.find(item.data));
         }
+        console.log(arrItems);
         if (type === 'tools') {
             return (await this.catalog.getActions(arrItems))?.filter(e => e.displayTool);
         }
@@ -57,94 +67,83 @@ export class VueCatalog {
             return (await this.catalog.getActions(arrItems))?.filter(e => e.displayContext);
         }
     }
-    async handleAction(actionId, items, config) {
+    async handleAction(actionId, items, data, req) {
         let arrItems = [];
         for (const item of items) {
             arrItems.push(await this.catalog.find(item.data));
         }
-        return this.catalog.handleAction(actionId, arrItems, config);
+        console.log(arrItems);
+        return this.catalog.handleAction(actionId, arrItems, data, req);
     }
-    async getPopUpHTML(actionId) {
-        return this.catalog.getPopUpHTML(actionId);
+    async getPopUpTemplate(actionId, req) {
+        return this.catalog.getPopUpTemplate(actionId, req);
     }
     async getLink(actionId) {
         return this.catalog.getLink(actionId);
     }
     //Below are the methods that require action
     async getCatalog() {
-        let rootItems = await this.catalog.getChilds(null);
+        let rootItems = await this.catalog.getChilds(0);
         return VueCatalogUtils.arrayToNode(rootItems, this.catalog.getGroupType().type);
     }
-    createItem(data) {
+    async createItem(data, req) {
+        // TODO It's not clear why it's here.
         //data = VueCatalogUtils.refinement(data);
-        if (this.catalog.slug !== "navigation") {
-            let item = data.record;
-            item.parenId = data.parenId;
-            return this.catalog.createItem(item);
-        }
-        else {
-            return this.catalog.createItem(data);
-        }
-    }
-    async getChilds(data) {
+        // if (this.catalog.slug !== "navigation") {
+        //     let item = data.record;
+        //     item.parenId = data.parenId;
+        //     return await this.catalog.createItem(item, req);
+        // } else {
+        return await this.catalog.createItem(data, req);
+        // }
+    }
+    async getChilds(data, req) {
         data = VueCatalogUtils.refinement(data);
-        return VueCatalogUtils.arrayToNode(await this.catalog.getChilds(data.id), this.catalog.getGroupType().type);
+        return VueCatalogUtils.arrayToNode(await this.catalog.getChilds(data.id, undefined, req), this.catalog.getGroupType().type);
     }
     // Moved into actions
     // getCreatedItems(data: any) {
     //   data = VueCatalogUtils.refinement(data);
     //   return this.catalog.getChilds(data.id);
     // }
-    async search(s) {
-        let searchResult = await this.catalog.search(s);
-        let itemsTree = AbstractCatalog.buildTree(searchResult);
-        return VueCatalogUtils.treeToNode(itemsTree, this.catalog.getGroupType().type);
-    }
-    async updateTree(data) {
-        let reqNodes = data.reqNode;
-        if (!Array.isArray(data.reqNode)) {
-            reqNodes = [data.reqNode];
-        }
+    async search(s, req) {
+        let searchResult = await this.catalog.search(s, undefined, req);
+        // let itemsTree = AbstractCatalog.buildTree(searchResult);
+        // console.log(itemsTree)
+        return VueCatalogUtils.treeToNode(searchResult, this.catalog.getGroupType().type);
+    }
+    async updateTree(data, req) {
+        // console.dir(data, {depth: null})
+        // return
         let reqParent = data.reqParent;
-        if (reqParent.data.id === 0) {
-            reqParent.data.id = null;
-        }
-        if (reqParent.data.id === undefined) {
-            throw `reqParent.data.id not defined`;
-        }
-        // It’s unclear why he’s coming reqNodes
-        for (const reqNode of reqNodes) {
-            const item = await this.catalog.find(reqNode.data);
-            if (!item) {
-                throw `reqNode Item not found`;
-            }
-        }
         // Update all items into parent (for two reason: update parent, updare sorting order)
         let sortCount = 0;
         for (const childNode of reqParent.children) {
             childNode.data.sortOrder = sortCount;
             childNode.data.parentId = reqParent.data.id;
-            await this.catalog.updateItem(childNode.data.id, childNode.data.type, childNode.data);
+            await this.catalog.updateItem(childNode.data.id, childNode.data.type, childNode.data, req);
             sortCount++;
         }
         return Promise.resolve('ok');
     }
-    async updateItem(item, modelId, data) {
+    async updateItem(item, modelId, data, req) {
+        //TODO It's not clear why it's here.
         //data = VueCatalogUtils.refinement(data);
-        if (this.catalog.slug !== "navigation") {
-            return await this.catalog.updateModelItems(data.modelId, data.type, data.record);
-        }
-        else {
-            return await this.catalog.updateModelItems(modelId, item.type, data);
-        }
-    }
-    async deleteItem(items) {
-        for (const item1 of items) {
-            if (item1.children?.length) {
-                await this.deleteItem(item1.children);
-            }
-            this.catalog.deleteItem(item1.data.type, item1.data.id);
-        }
+        // if (this.catalog.slug !== "navigation") {
+        //     return await this.catalog.updateModelItems(data.modelId, data.type, data.record, req);
+        // } else {
+        return await this.catalog.updateModelItems(modelId, item.type, data, req);
+        // }
+    }
+    async deleteItem(item, req) {
+        // Получаем всех непосредственных потомков текущего элемента
+        const children = await this.catalog.getChilds(item.id, undefined, req);
+        // Рекурсивно удаляем всех потомков
+        for (const child of children) {
+            await this.deleteItem(child, req);
+        }
+        // После удаления всех потомков удаляем сам элемент
+        await this.catalog.deleteItem(item.type, item.id, req);
         return { ok: true };
     }
 }
@@ -161,16 +160,16 @@ export class VueCatalogUtils {
     static toNode(data, groupTypeName) {
         return {
             data: data,
-            isLeaf: data.type !== groupTypeName,
-            isExpanded: false,
-            ind: data.sortOrder,
-            title: data.name
+            droppable: data.type === groupTypeName,
+            id: data.id,
+            text: data.name,
+            parent: data.parentId,
         };
     }
     static expandTo(vueCatalogData, theseItemIdsNeedToBeOpened) {
         function expand(node) {
             if (theseItemIdsNeedToBeOpened.includes(node.data.id)) {
-                node.isExpanded = true;
+                // node.isExpanded = true;
             }
             if (node.children) {
                 for (const child of node.children) {
@@ -191,7 +190,7 @@ export class VueCatalogUtils {
                     // Sort the children before building their nodes
                     item.childs.sort((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0));
                     node.children = buildNodes(item.childs);
-                    node.isExpanded = !node.isLeaf;
+                    // node.isExpanded = !node.droppable;
                 }
                 return node;
             });

package/controllers/edit.js

@@ -1,7 +1,7 @@
 import { ControllerHelper } from "../helpers/controllerHelper";
 import { RequestProcessor } from "../lib/requestProcessor";
 import { FieldsHelper } from "../helpers/fieldsHelper";
-import { CatalogHandler } from "../lib/catalog/CatalogHandler";
+import { CatalogHandler } from "../lib/v4/catalog/CatalogHandler";
 import { getRelationsMediaManager, saveRelationsMediaManager } from "../lib/media-manager/helpers/MediaManagerHelper";
 import { DataAccessor } from "../lib/v4/DataAccessor";
 import { Adminizer } from "../lib/Adminizer";
@@ -30,7 +30,7 @@ export default async function edit(req, res) {
     let dataAccessor;
     try {
         const id = req.params.id;
-        dataAccessor = new DataAccessor(req, entity, "edit");
+        dataAccessor = new DataAccessor(req.adminizer, req.user, entity, "edit");
         record = await entity.model.findOne({ id: id }, dataAccessor);
         if (!record)
             return res.status(404).send("Adminpanel > Record not found");
@@ -125,7 +125,7 @@ export default async function edit(req, res) {
                     for (const section of req.adminizer.config.navigation.sections) {
                         let navigation = CatalogHandler.getCatalog('navigation');
                         navigation.setId(section);
-                        let navItem = navigation.itemTypes.find(item => item.type === entity.name);
+                        let navItem = navigation.itemTypes.find(item => item.type === entity.name.toLowerCase());
                         if (navItem) {
                             await navItem.updateModelItems(newRecord[0].id, { record: newRecord[0] }, section);
                         }
@@ -155,16 +155,13 @@ export default async function edit(req, res) {
             }
         }
     }
-    if (req.query.without_layout) {
-        // return res.viewAdmin("./../ejs/partials/content/editPopup.ejs", {
-        //     entity: entity,
-        //     record: record,
-        //     fields: fields
-        // });
-        return null;
+    const props = inertiaAddHelper(req, entity, fields, record);
+    if (req.query?.without_layout) {
+        return res.json({
+            props: props
+        });
     }
     else {
-        const props = inertiaAddHelper(req, entity, fields, record);
         return req.Inertia.render({
             component: 'add',
             props: props

package/controllers/list.js

@@ -1,6 +1,6 @@
 import { ControllerHelper } from "../helpers/controllerHelper";
 import { DataAccessor } from "../lib/v4/DataAccessor";
-import { NodeTable } from "../lib/datatable/NodeTable";
+import { NodeTable } from "../lib/v4/datatable/NodeTable";
 import { Adminizer } from "../lib/Adminizer";
 import { inertiaListHelper } from "../helpers/inertiaListHelper";
 export default async function list(req, res) {
@@ -16,7 +16,7 @@ export default async function list(req, res) {
             return res.sendStatus(403);
         }
     }
-    let dataAccessor = new DataAccessor(req, entity, "list");
+    let dataAccessor = new DataAccessor(req.adminizer, req.user, entity, "list");
     let fields = dataAccessor.getFieldsConfig();
     const header = inertiaListHelper(entity, req, fields);
     let start = "0";

package/controllers/login.js

@@ -33,10 +33,12 @@ export default async function login(req, res) {
                 }
                 return req.Inertia.redirect(`${req.adminizer.config.routePrefix}/`);
             }
-            // Verify CAPTCHA solution
-            const isCaptchaValid = powCaptcha.check(captchaSolution, `login:${req.ip}`);
-            if (!isCaptchaValid) {
-                return inertiaAdminMessage(req, "Invalid CAPTCHA solution", 'captchaSolution');
+            // Verify CAPTCHA solution if enabled
+            if (req.adminizer.config.auth.captcha !== false) {
+                const isCaptchaValid = powCaptcha.check(captchaSolution, `login:${req.ip}`);
+                if (!isCaptchaValid) {
+                    return inertiaAdminMessage(req, "Invalid CAPTCHA solution", 'captchaSolution');
+                }
             }
             if (!user) {
                 return inertiaAdminMessage(req, "Wrong username", 'login');
@@ -66,8 +68,11 @@ export default async function login(req, res) {
             }
         }
         if (req.method.toUpperCase() === "GET") {
-            // Generate new CAPTCHA job
-            const captchaTask = await powCaptcha.getJob(`login:${req.ip}`);
+            // Generate new CAPTCHA task if enabled
+            let captchaTask = [];
+            if (req.adminizer.config.auth.captcha !== false) {
+                captchaTask = await powCaptcha.getJob(`login:${req.ip}`);
+            }
             return req.Inertia.render({
                 component: 'login',
                 props: {
@@ -97,7 +102,11 @@ export default async function login(req, res) {
 async function inertiaAdminMessage(req, message, messageType) {
     Adminizer.log.warn(message);
     const powCaptcha = new POWCaptcha();
-    const captchaTask = await powCaptcha.getJob(`login:${req.ip}`);
+    // Generate new CAPTCHA task if enabled
+    let captchaTask = [];
+    if (req.adminizer.config.auth.captcha !== false) {
+        captchaTask = await powCaptcha.getJob(`login:${req.ip}`);
+    }
     let errors = {};
     errors[messageType] = message;
     return req.Inertia.render({

package/controllers/navigation/edit.js

@@ -7,7 +7,7 @@ export default async function edit(req, res) {
         }
     }
     let entity = ControllerHelper.findEntityObject(req);
-    let dataAccessor = new DataAccessor(req, entity, "edit");
+    let dataAccessor = new DataAccessor(req.adminizer, req.user, entity, "edit");
     let record = await entity.model.findOne({ id: req.params.id }, dataAccessor);
     return res.redirect(`${req.adminizer.config.routePrefix}/catalog/navigation/${record.label}`);
 }

package/controllers/remove.js

@@ -31,7 +31,7 @@ export default async function remove(req, res) {
     let record;
     let dataAccessor;
     try {
-        dataAccessor = new DataAccessor(req, entity, "remove");
+        dataAccessor = new DataAccessor(req.adminizer, req.user, entity, "remove");
         record = await entity.model.findOne({ id: req.params.id }, dataAccessor);
     }
     catch (e) {

package/controllers/view.js

@@ -25,7 +25,7 @@ export default async function view(req, res) {
             return res.sendStatus(403);
         }
     }
-    let dataAccessor = new DataAccessor(req, entity, "view");
+    let dataAccessor = new DataAccessor(req.adminizer, req.user, entity, "view");
     let fields = dataAccessor.getFieldsConfig();
     let record;
     try {

package/helpers/JsUtils.d.ts

@@ -0,0 +1 @@
+export declare function isObject(obj: unknown): obj is object;

package/helpers/JsUtils.js

@@ -0,0 +1,3 @@
+export function isObject(obj) {
+    return typeof obj === "object" && obj !== null;
+}

package/helpers/accessRightsHelper.d.ts

@@ -13,3 +13,6 @@ export declare class AccessRightsHelper {
     enoughPermissions(tokens: string[], user: UserAP): boolean;
     hasPermission(tokenId: string, user: UserAP): boolean;
 }
+export declare class GroupsAccessRightsHelper {
+    static hasAccess(user: UserAP, groupsAccessRights?: string[]): boolean;
+}

package/helpers/accessRightsHelper.js

@@ -6,12 +6,14 @@ export class AccessRightsHelper {
         this.adminizer = adminizer;
     }
     registerToken(accessRightsToken) {
+        accessRightsToken.id = accessRightsToken.id.toLowerCase();
         if (!accessRightsToken.id || !accessRightsToken.name || !accessRightsToken.description || !accessRightsToken.department) {
             throw new Error("Adminpanel > Can not register token: Missed one or more required parameters");
         }
-        for (let token of this._tokens) {
-            if (token.id === accessRightsToken.id) {
-                throw new Error("Adminpanel > Can not register token: Token with this id already registered");
+        for (let i = 0; i < this._tokens.length; i++) {
+            if (this._tokens[i].id === accessRightsToken.id) {
+                this._tokens.splice(i, 1);
+                break;
             }
         }
         this._tokens.push(accessRightsToken);
@@ -42,6 +44,11 @@ export class AccessRightsHelper {
         return tokens.some((token) => this.hasPermission(token, user));
     }
     hasPermission(tokenId, user) {
+        if (!tokenId) {
+            Adminizer.log.error(`AccessRightsHelper > hasPermission no tokenId: ${tokenId}`);
+            return false;
+        }
+        tokenId = tokenId.toLowerCase();
         if (!this.adminizer.config.auth.enable) {
             return true;
         }
@@ -50,9 +57,25 @@ export class AccessRightsHelper {
         }
         const tokenIsValid = this._tokens.some((token) => token.id === tokenId);
         if (!tokenIsValid) {
-            Adminizer.log.error("Adminpanel > Token is not valid");
+            Adminizer.log.error("Adminpanel > Token is not valid", tokenId, user.login);
+            return false;
+        }
+        if (!user.groups) {
+            Adminizer.log.error('User has no groups');
             return false;
         }
         return user.groups.some((group) => group.tokens?.includes(tokenId));
     }
 }
+export class GroupsAccessRightsHelper {
+    static hasAccess(user, groupsAccessRights) {
+        const userGroups = user.groups?.map(group => group.name.toLowerCase());
+        if (groupsAccessRights) {
+            const allowedGroups = groupsAccessRights.map(item => item.toLowerCase());
+            return userGroups?.some(group => allowedGroups.includes(group)) ?? false;
+        }
+        else {
+            return true;
+        }
+    }
+}