adminizer 4.1.0-commit.ad1476a → 4.1.1

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) {
@@ -6,10 +6,10 @@ export async function catalogController(req, res) {
     let id = req.params.id ? req.params.id : '';
     const postfix = id ? `${slug}-${id}` : `${slug}`;
     if (req.adminizer.config.auth.enable) {
-        if (!req.session.UserAP) {
+        if (!req.user) {
             return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
         }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`catalog-${postfix}`, req.session.UserAP)) {
+        else if (!req.adminizer.accessRightsHelper.hasPermission(`catalog-${postfix}`, req.user)) {
             return res.sendStatus(403);
         }
     }
@@ -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.session.UserAP.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,95 +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) {
-            // console.log(">>>>>>>>>", "this.catalog.find", reqNode)
-            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 };
     }
 }
@@ -162,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) {
@@ -192,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/ckeditorUpload.js

@@ -2,10 +2,9 @@ import { ControllerHelper } from "../helpers/controllerHelper";
 import * as fs from "fs";
 import { Adminizer } from "../lib/Adminizer";
 export default function upload(req, res) {
-    //console.log('admin > CK-upload');
     let entity = ControllerHelper.findEntityObject(req);
     if (req.adminizer.config.auth.enable) {
-        if (!req.session.UserAP) {
+        if (!req.user) {
             res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
             return;
         }
@@ -14,7 +13,7 @@ export default function upload(req, res) {
             `create-${entity.name}-model`,
             `update-${entity.name}-form`,
             `create-${entity.name}-form`
-        ], req.session.UserAP)) {
+        ], req.user)) {
             res.sendStatus(403);
             return;
         }

package/controllers/dashboard.js

@@ -1,10 +1,24 @@
 export default function (req, res) {
-    if (req.adminizer.config.auth.enable && !req.session.UserAP) {
+    if (req.adminizer.config.auth.enable && !req.user) {
         return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
     }
     return req.Inertia.render({
         component: 'dashboard',
-        props: null
+        props: {
+            title: req.i18n.__('Quick actions'),
+            tooltip: req.i18n.__('Toggle to change the grid. To save the grid, turn it off.'),
+            notWidgets: req.i18n.__('You don\'t have any widgets selected yet. You can add them by clicking on the plus sign at the top right.'),
+            notFound: req.i18n.__('No widgets found'),
+            actionsTitles: {
+                "All": req.i18n.__('All'),
+                'Custom': req.i18n.__('Custom'),
+                'Fast links': req.i18n.__('Fast links'),
+                'Actions': req.i18n.__('Actions'),
+                'Info': req.i18n.__('Info'),
+                'Switcher': req.i18n.__('Switcher')
+            },
+            searchPlaceholder: req.i18n.__('Search'),
+        }
     });
 }
 ;

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";
@@ -19,10 +19,10 @@ export default async function edit(req, res) {
         return res.redirect(`${req.adminizer.config.routePrefix}/${entity.uri}`);
     }
     if (req.adminizer.config.auth.enable) {
-        if (!req.session.UserAP) {
+        if (!req.user) {
             return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
         }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`update-${entity.name}-model`, req.session.UserAP)) {
+        else if (!req.adminizer.accessRightsHelper.hasPermission(`update-${entity.name}-model`, req.user)) {
             return res.sendStatus(403);
         }
     }
@@ -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);
                         }
@@ -145,7 +145,6 @@ export default async function edit(req, res) {
         let fieldConfigConfig = fields[field].config;
         if (fieldConfigConfig.type === 'mediamanager') {
             if (fields[field].model.type === 'association-many') {
-                console.log(fieldConfigConfig.options);
                 record[field] = await getRelationsMediaManager({
                     list: record[field],
                     mediaManagerId: fieldConfigConfig.options.id ?? "default"
@@ -156,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/editGroup.js

@@ -4,10 +4,10 @@ import { inertiaGroupHelper } from "../helpers/inertiaGroupHelper";
 export default async function editGroup(req, res) {
     let entity = ControllerHelper.findEntityObject(req);
     if (req.adminizer.config.auth.enable) {
-        if (!req.session.UserAP) {
+        if (!req.user) {
             return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
         }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`update-${entity.name}-model`, req.session.UserAP)) {
+        else if (!req.adminizer.accessRightsHelper.hasPermission(`update-${entity.name}-model`, req.user)) {
             return res.sendStatus(403);
         }
     }
@@ -40,7 +40,6 @@ export default async function editGroup(req, res) {
     }
     let reloadNeeded = false;
     if (req.method.toUpperCase() === 'POST') {
-        // console.log(req.body);
         let allTokens = req.adminizer.accessRightsHelper.getTokens();
         let usersInThisGroup = [];
         let tokensOfThisGroup = [];
@@ -95,7 +94,6 @@ export default async function editGroup(req, res) {
             Adminizer.log.error(e);
         }
     }
-    // console.log("GROUP", group)
     const props = inertiaGroupHelper(entity, req, users, groupedTokens, group);
     return req.Inertia.render({
         component: 'add-group',

package/controllers/editUser.js

@@ -5,10 +5,10 @@ import { inertiaUserHelper } from "../helpers/inertiaUserHelper";
 export default async function (req, res) {
     let entity = ControllerHelper.findEntityObject(req);
     if (req.adminizer.config.auth.enable) {
-        if (!req.session.UserAP) {
+        if (!req.user) {
             return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
         }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`update-${entity.name}-model`, req.session.UserAP)) {
+        else if (!req.adminizer.accessRightsHelper.hasPermission(`update-${entity.name}-model`, req.user)) {
             return res.sendStatus(403);
         }
     }
@@ -36,7 +36,6 @@ export default async function (req, res) {
     }
     let reloadNeeded = false;
     if (req.method.toUpperCase() === 'POST') {
-        // console.log(req.body);
         let userGroups = [];
         for (let key in req.body) {
             if (key.startsWith("group-checkbox-") && req.body[key] === true) {
@@ -62,12 +61,11 @@ export default async function (req, res) {
                 locale: locale, isAdministrator: isAdministrator, isConfirmed: isConfirmed, groups: userGroups
             });
             if (req.body.userPassword) {
-                let passwordHashed = generate(req.body.login + req.body.userPassword);
+                let passwordHashed = generate(req.body.login + req.body.userPassword + process.env.AP_PASSWORD_SALT);
                 let password = 'masked';
                 // TODO refactor CRUD functions for DataAccessor usage
                 updatedUser = await req.adminizer.modelHandler.model.get("UserAP")["_updateOne"]({ id: user.id }, {
                     login: req.body.login,
-                    password: password,
                     passwordHashed: passwordHashed
                 });
             }

package/controllers/form.js

@@ -8,10 +8,10 @@ export default async function form(req, res) {
         return res.status(404).send({ error: 'Not Found' });
     }
     if (req.adminizer.config.auth.enable) {
-        if (!req.session.UserAP) {
+        if (!req.user) {
             return res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
         }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`update-${slug}-form`, req.session.UserAP)) {
+        else if (!req.adminizer.accessRightsHelper.hasPermission(`update-${slug}-form`, req.user)) {
             return res.sendStatus(403);
         }
     }
@@ -61,7 +61,6 @@ export default async function form(req, res) {
         }
     }
     const props = inertiaFormHelper(req, `${req.adminizer.config.routePrefix}/form/${slug}`, form);
-    // console.log(props)
     return req.Inertia.render({
         component: 'form',
         props: props