adminizer 4.3.0-build.98 → 4.3.0

package/controllers/catalog/Catalog.js

@@ -1,4 +1,4 @@
-import { VueCatalog } from "./FrontentCatalogAdapter";
+import { FrontendCatalog, FrontendCatalogUtils } from "./FrontendCatalogAdapter";
 import { Adminizer } from "../../lib/Adminizer";
 export async function catalogController(req, res) {
     const slug = req.params.slug;
@@ -34,7 +34,7 @@ export async function catalogController(req, res) {
     }
     if (method === 'POST' || method === 'PUT' || method === 'DELETE') {
         const data = req.body;
-        const frontendCatalog = new VueCatalog(_catalog);
+        const frontendCatalog = new FrontendCatalog(_catalog);
         if (!frontendCatalog)
             return res.status(404);
         frontendCatalog.setId(id);
@@ -46,24 +46,24 @@ export async function catalogController(req, res) {
                         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 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 'getCatalog': {
+                        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 frontendCatalog.createItem(data.data, req) });
+                        const createdItem = await frontendCatalog.createItem(data.data, req);
+                        return res.json({ 'data': FrontendCatalogUtils.normalizeForFrontend(createdItem) });
                     case 'getChilds':
                         return res.json({ data: await frontendCatalog.getChilds(data.data, req) });
                     case 'getActions':
@@ -85,7 +85,8 @@ export async function catalogController(req, res) {
                     case 'getPopUpTemplate':
                         return res.json({ data: await frontendCatalog.getPopUpTemplate(data.actionId, req) });
                     case 'updateItem':
-                        return res.json({ data: await frontendCatalog.updateItem(item, data.modelId, data.data, req) });
+                        const updatedItem = await frontendCatalog.updateItem(item, data.modelId, data.data, req);
+                        return res.json({ data: FrontendCatalogUtils.normalizeForFrontend(updatedItem) });
                 }
                 break;
             case 'DELETE':

package/controllers/catalog/FrontendCatalogAdapter.d.ts

@@ -0,0 +1,82 @@
+import { AbstractCatalog, Item } from "../../lib/catalog/AbstractCatalog";
+interface NodeModel<TDataType> {
+    text: string;
+    droppable: boolean;
+    id: string;
+    parent: number;
+    data?: TDataType;
+    children?: NodeModel<TDataType>[];
+    isSelected?: boolean;
+    isVisible?: boolean;
+    isDraggable?: boolean;
+    isSelectable?: boolean;
+    path?: number[];
+    pathStr?: string;
+    level?: number;
+    isFirstChild?: boolean;
+    isLastChild?: boolean;
+}
+interface NodeData extends Item {
+}
+interface RequestData {
+    reqNode: NodeModel<NodeData>[];
+    reqParent: NodeModel<NodeData>;
+    _method: string;
+}
+/**
+ * @deprecated Now is React
+ * // TODO: refactor for react name
+ */
+export declare class FrontendCatalog {
+    catalog: AbstractCatalog;
+    constructor(_catalog: AbstractCatalog);
+    setId(id: string): void;
+    getItemType(type: string): import("../../lib/catalog/AbstractCatalog").BaseItem<Item>;
+    getAddTemplate(item: any, req: ReqType): Promise<{
+        type: "component" | "navigation.group" | "navigation.link" | "model" | "model.link";
+        data: any;
+    }>;
+    getEditTemplate(item: any, id: string | number, req: ReqType, modelId: string | number): Promise<{
+        type: "component" | "navigation.group" | "navigation.link" | "model" | "model.link";
+        data: any;
+    }>;
+    getitemTypes(): {
+        type: string;
+        name: string;
+        isGroup: boolean;
+        allowedRoot: boolean;
+        icon: string;
+        actionHandlers: import("../../lib/catalog/AbstractCatalog").ActionHandler[];
+    }[];
+    getLocales(req: ReqType): {
+        [key: string]: string;
+    };
+    getActions(items: NodeModel<any>[], type: string): Promise<import("../../lib/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, 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;
+    }>;
+}
+export declare class FrontendCatalogUtils {
+    /**
+     * Removes unnecessary data from the front
+     */
+    static refinement<T extends NodeModel<any>>(nodeModel: T): any;
+    /**
+     * Normalizes data for frontend: replaces null parentId with 0
+     */
+    static normalizeForFrontend<T extends Item>(item: T): T;
+    static arrayToNode<T extends Item>(items: T[], groupTypeName: string): NodeModel<T>[];
+    static toNode<T extends NodeData>(data: T, groupTypeName: string): NodeModel<T>;
+    static expandTo<T extends NodeData>(frontendCatalogData: NodeModel<T>, theseItemIdsNeedToBeOpened: (string | number)[]): NodeModel<T>;
+    static treeToNode(tree: Item[], groupTypeName: string): NodeModel<Item>[];
+}
+export {};

package/controllers/catalog/FrontendCatalogAdapter.js

@@ -0,0 +1,228 @@
+/**
+ * @deprecated Now is React
+ * // TODO: refactor for react name
+ */
+export class FrontendCatalog {
+    catalog;
+    constructor(_catalog) {
+        this.catalog = _catalog;
+    }
+    setId(id) {
+        this.catalog.setId(id);
+    }
+    getItemType(type) {
+        return this.catalog.getItemType(type);
+    }
+    getAddTemplate(item, req) {
+        return this.catalog.getAddTemplate(item, req);
+    }
+    getEditTemplate(item, id, req, modelId) {
+        return this.catalog.getEditTemplate(item, id, req, modelId);
+    }
+    getitemTypes() {
+        return this.catalog.getitemTypes();
+    }
+    getLocales(req) {
+        let obj = {
+            "Delete": "",
+            "Edit": "",
+            "create": "",
+            "Search": "",
+            "Select Item type": "",
+            "Select Items": "",
+            "Save": "",
+            "No": "",
+            "Are you sure?": "",
+            "Yes": "",
+            "Select Ids": "",
+            "OR": "",
+            "Open in a new window": "",
+            "Visible": "",
+            "Clean": "",
+            "Performing an action...": "",
+            "Action completed": "",
+        };
+        obj[this.catalog.name] = "";
+        for (const actionHandler of this.catalog.actionHandlers) {
+            obj[actionHandler.name] = "";
+        }
+        let messages = obj;
+        let outMessages = {};
+        for (const mess of Object.keys(messages)) {
+            outMessages[mess] = req.i18n.__(mess);
+        }
+        return {
+            ...outMessages,
+        };
+    }
+    async getActions(items, type) {
+        let arrItems = [];
+        for (const item of items) {
+            if (item.data.id === 0)
+                item.data.id = null;
+            arrItems.push(await this.catalog.find(item.data));
+        }
+        console.log(arrItems);
+        if (type === 'tools') {
+            return (await this.catalog.getActions(arrItems))?.filter(e => e.displayTool);
+        }
+        else {
+            return (await this.catalog.getActions(arrItems))?.filter(e => e.displayContext);
+        }
+    }
+    async handleAction(actionId, items, data, req) {
+        let arrItems = [];
+        for (const item of items) {
+            if (item.data.id === 0)
+                item.data.id = null;
+            arrItems.push(await this.catalog.find(item.data));
+        }
+        console.log(arrItems);
+        return this.catalog.handleAction(actionId, arrItems, data, req);
+    }
+    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);
+        return FrontendCatalogUtils.arrayToNode(rootItems, this.catalog.getGroupType().type);
+    }
+    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 await this.catalog.createItem(item, req);
+        // } else {
+        if (data.parentId === 0)
+            data.parentId = null;
+        return await this.catalog.createItem(data, req);
+        // }
+    }
+    async getChilds(data, req) {
+        data = FrontendCatalogUtils.refinement(data);
+        if (!data || data.id === 0 || data.id === undefined) {
+            data = { id: null };
+        }
+        if (data.id === 0)
+            data.id = null;
+        return FrontendCatalogUtils.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, req) {
+        let searchResult = await this.catalog.search(s, undefined, req);
+        // let itemsTree = AbstractCatalog.buildTree(searchResult);
+        // console.log(itemsTree)
+        return FrontendCatalogUtils.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;
+        // 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;
+            if (childNode.data.id === 0)
+                childNode.data.id = null;
+            await this.catalog.updateItem(childNode.data.id, childNode.data.type, childNode.data, req);
+            sortCount++;
+        }
+        return Promise.resolve('ok');
+    }
+    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, req);
+        // } else {
+        let normalizedModelId = modelId;
+        if (normalizedModelId === '0')
+            normalizedModelId = null;
+        return await this.catalog.updateModelItems(normalizedModelId, item.type, data, req);
+        // }
+    }
+    async deleteItem(item, req) {
+        if (item.id === 0)
+            item.id = null;
+        // Получаем всех непосредственных потомков текущего элемента
+        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 };
+    }
+}
+export class FrontendCatalogUtils {
+    /**
+     * Removes unnecessary data from the front
+     */
+    static refinement(nodeModel) {
+        return nodeModel.data;
+    }
+    /**
+     * Normalizes data for frontend: replaces null parentId with 0
+     */
+    static normalizeForFrontend(item) {
+        return { ...item, parentId: item.parentId === null ? 0 : item.parentId };
+    }
+    static arrayToNode(items, groupTypeName) {
+        return items.map(node => FrontendCatalogUtils.toNode(node, groupTypeName));
+    }
+    static toNode(data, groupTypeName) {
+        const normalizedData = FrontendCatalogUtils.normalizeForFrontend(data);
+        return {
+            data: normalizedData,
+            droppable: data.type === groupTypeName,
+            id: data.id,
+            text: data.name,
+            parent: (data.parentId === null ? 0 : data.parentId),
+        };
+    }
+    static expandTo(frontendCatalogData, theseItemIdsNeedToBeOpened) {
+        function expand(node) {
+            if (theseItemIdsNeedToBeOpened.includes(node.data.id)) {
+                // node.isExpanded = true;
+            }
+            if (node.children) {
+                for (const child of node.children) {
+                    expand(child);
+                }
+            }
+        }
+        theseItemIdsNeedToBeOpened.forEach(id => {
+            expand(frontendCatalogData);
+        });
+        return frontendCatalogData;
+    }
+    static treeToNode(tree, groupTypeName) {
+        function buildNodes(items) {
+            return items.map(item => {
+                const node = FrontendCatalogUtils.toNode(item, groupTypeName);
+                if (item.childs && item.childs.length > 0) {
+                    // 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.droppable;
+                }
+                return node;
+            });
+        }
+        return buildNodes(tree);
+    }
+}

package/controllers/catalog/FrontentCatalogAdapter.d.ts

@@ -27,17 +27,17 @@ interface RequestData {
  * @deprecated Now is React
  * // TODO: refactor for react name
  */
-export declare class VueCatalog {
+export declare class FrontendCatalog {
     catalog: AbstractCatalog;
     constructor(_catalog: AbstractCatalog);
     setId(id: string): void;
     getItemType(type: string): import("../../lib/catalog/AbstractCatalog").BaseItem<Item>;
     getAddTemplate(item: any, req: ReqType): Promise<{
-        type: "component" | "navigation.group" | "navigation.link" | "model";
+        type: "component" | "navigation.group" | "navigation.link" | "model" | "model.link";
         data: any;
     }>;
     getEditTemplate(item: any, id: string | number, req: ReqType, modelId: string | number): Promise<{
-        type: "component" | "navigation.group" | "navigation.link" | "model";
+        type: "component" | "navigation.group" | "navigation.link" | "model" | "model.link";
         data: any;
     }>;
     getitemTypes(): {
@@ -65,7 +65,7 @@ export declare class VueCatalog {
         ok: boolean;
     }>;
 }
-export declare class VueCatalogUtils {
+export declare class FrontendCatalogUtils {
     /**
      * Removes unnecessary data from the front
      */

package/controllers/catalog/FrontentCatalogAdapter.js

@@ -2,7 +2,7 @@
  * @deprecated Now is React
  * // TODO: refactor for react name
  */
-export class VueCatalog {
+export class FrontendCatalog {
     catalog;
     constructor(_catalog) {
         this.catalog = _catalog;
@@ -37,6 +37,7 @@ export class VueCatalog {
             "Select Ids": "",
             "OR": "",
             "Open in a new window": "",
+            "Visible": "",
             "Clean": "",
             "Performing an action...": "",
             "Action completed": "",
@@ -57,6 +58,8 @@ export class VueCatalog {
     async getActions(items, type) {
         let arrItems = [];
         for (const item of items) {
+            if (item.data.id === 0)
+                item.data.id = null;
             arrItems.push(await this.catalog.find(item.data));
         }
         console.log(arrItems);
@@ -70,6 +73,8 @@ export class VueCatalog {
     async handleAction(actionId, items, data, req) {
         let arrItems = [];
         for (const item of items) {
+            if (item.data.id === 0)
+                item.data.id = null;
             arrItems.push(await this.catalog.find(item.data));
         }
         console.log(arrItems);
@@ -83,8 +88,8 @@ export class VueCatalog {
     }
     //Below are the methods that require action
     async getCatalog() {
-        let rootItems = await this.catalog.getChilds(0);
-        return VueCatalogUtils.arrayToNode(rootItems, this.catalog.getGroupType().type);
+        let rootItems = await this.catalog.getChilds(null);
+        return FrontendCatalogUtils.arrayToNode(rootItems, this.catalog.getGroupType().type);
     }
     async createItem(data, req) {
         // TODO It's not clear why it's here.
@@ -94,12 +99,16 @@ export class VueCatalog {
         //     item.parenId = data.parenId;
         //     return await this.catalog.createItem(item, req);
         // } else {
+        if (data.parentId === 0)
+            data.parentId = null;
         return await this.catalog.createItem(data, req);
         // }
     }
     async getChilds(data, req) {
-        data = VueCatalogUtils.refinement(data);
-        return VueCatalogUtils.arrayToNode(await this.catalog.getChilds(data.id, undefined, req), this.catalog.getGroupType().type);
+        data = FrontendCatalogUtils.refinement(data);
+        if (data.id === 0)
+            data.id = null;
+        return FrontendCatalogUtils.arrayToNode(await this.catalog.getChilds(data.id, undefined, req), this.catalog.getGroupType().type);
     }
     // Moved into actions
     // getCreatedItems(data: any) {
@@ -110,17 +119,21 @@ export class VueCatalog {
         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);
+        return FrontendCatalogUtils.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;
         // 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;
+            if (childNode.data.id === 0)
+                childNode.data.id = null;
             await this.catalog.updateItem(childNode.data.id, childNode.data.type, childNode.data, req);
             sortCount++;
         }
@@ -132,10 +145,15 @@ export class VueCatalog {
         // 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);
+        let normalizedModelId = modelId;
+        if (normalizedModelId === '0')
+            normalizedModelId = null;
+        return await this.catalog.updateModelItems(normalizedModelId, item.type, data, req);
         // }
     }
     async deleteItem(item, req) {
+        if (item.id === 0)
+            item.id = null;
         // Получаем всех непосредственных потомков текущего элемента
         const children = await this.catalog.getChilds(item.id, undefined, req);
         // Рекурсивно удаляем всех потомков
@@ -147,7 +165,7 @@ export class VueCatalog {
         return { ok: true };
     }
 }
-export class VueCatalogUtils {
+export class FrontendCatalogUtils {
     /**
      * Removes unnecessary data from the front
      */
@@ -155,7 +173,7 @@ export class VueCatalogUtils {
         return nodeModel.data;
     }
     static arrayToNode(items, groupTypeName) {
-        return items.map(node => VueCatalogUtils.toNode(node, groupTypeName));
+        return items.map(node => FrontendCatalogUtils.toNode(node, groupTypeName));
     }
     static toNode(data, groupTypeName) {
         return {
@@ -185,7 +203,7 @@ export class VueCatalogUtils {
     static treeToNode(tree, groupTypeName) {
         function buildNodes(items) {
             return items.map(item => {
-                const node = VueCatalogUtils.toNode(item, groupTypeName);
+                const node = FrontendCatalogUtils.toNode(item, groupTypeName);
                 if (item.childs && item.childs.length > 0) {
                     // Sort the children before building their nodes
                     item.childs.sort((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0));

package/controllers/edit.js

@@ -44,6 +44,8 @@ export default async function edit(req, res) {
     fields = await FieldsHelper.loadAssociations(req, fields, "edit");
     // Save
     if (req.method.toUpperCase() === 'POST') {
+        const backUrl = req.body.redirectUrl;
+        delete req.body.redirectUrl;
         let reqData = RequestProcessor.processRequest(req, fields);
         let params = {};
         params[entity.config.identifierField || req.adminizer.config.identifierField] = req.params.id;
@@ -112,7 +114,7 @@ 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);
+            await saveRelationsMediaManager(req.adminizer, fields, rawReqData, entity.model.modelname, newRecord[0].id);
             Adminizer.log.debug(`Record was updated: `, newRecord);
             if (req.body.jsonPopupCatalog) {
                 return res.json({ record: newRecord });
@@ -130,7 +132,12 @@ export default async function edit(req, res) {
                     }
                 }
                 req.flash.setFlashMessage('success', req.i18n.__('Record was updated'));
-                return req.Inertia.redirect(`${req.adminizer.config.routePrefix}/model/${entity.name}`);
+                if (backUrl) {
+                    return req.Inertia.redirect(backUrl);
+                }
+                else {
+                    return req.Inertia.redirect(`${req.adminizer.config.routePrefix}/model/${entity.name}`);
+                }
             }
         }
         catch (e) {
@@ -142,9 +149,11 @@ export default async function edit(req, res) {
     for (const field of Object.keys(fields)) {
         let fieldConfigConfig = fields[field].config;
         if (fieldConfigConfig.type === 'mediamanager') {
-            record[field] = await getRelationsMediaManager({
-                list: record[field],
-                mediaManagerId: fieldConfigConfig.options?.id ?? "default"
+            record[field] = await getRelationsMediaManager(req.adminizer, {
+                mediaManagerId: fieldConfigConfig.options?.id ?? "default",
+                model: entity.model.modelname,
+                widgetName: field,
+                modelId: id
             });
         }
     }

package/controllers/form.js

@@ -2,7 +2,6 @@ import { FormHelper } from "../helpers/formHelper";
 import { Adminizer } from "../lib/Adminizer";
 import inertiaFormHelper from "../helpers/inertiaFromHelper";
 import { getRelationsMediaManager } from "../lib/media-manager/helpers/MediaManagerHelper";
-import { MediaManagerHandler } from "../lib/media-manager/MediaManagerHandler";
 export default async function form(req, res) {
     let slug = req.params.slug;
     // Check slug
@@ -45,8 +44,9 @@ export default async function form(req, res) {
             }
             if (form[key].type === "mediamanager") {
                 let options = form[key].options;
-                let mediaManager = MediaManagerHandler.get(options?.id ?? "default");
-                await mediaManager.setRelations(req.body[key], "form", `${slug}_${key}`, key);
+                let mediaManager = req.adminizer.mediaManagerHandler.get(options?.id ?? "default");
+                if (req.body[key])
+                    await mediaManager.setRelations(req.body[key], `${slug}_${key}`, 0, key);
             }
         }
         for (let field of Object.keys(req.body)) {
@@ -62,9 +62,11 @@ export default async function form(req, res) {
     for (let key of Object.keys(form)) {
         try {
             if (form[key].type === 'mediamanager') {
-                form[key].value = await getRelationsMediaManager({
-                    list: await req.adminizer.config.forms.get(slug, key),
-                    mediaManagerId: form[key].options?.id ?? "default"
+                form[key].value = await getRelationsMediaManager(req.adminizer, {
+                    mediaManagerId: form[key].options?.id ?? "default",
+                    model: `${slug}_${key}`,
+                    widgetName: key,
+                    modelId: 0
                 });
             }
             else {

package/controllers/login.js

@@ -53,6 +53,9 @@ export default async function login(req, res) {
                         //Here we use the captchaSolution key to output messages unrelated to the form fields.
                         return inertiaAdminMessage(req, "Profile expired, contact the administrator", 'captchaSolution');
                     }
+                    if (!req.adminizer.accessRightsHelper.hasPermission('access-to-adminpanel', user)) {
+                        return inertiaAdminMessage(req, "The user is not allowed to enter, please contact the administrator", 'captchaSolution');
+                    }
                     const token = signUser(user, req.adminizer.jwtSecret);
                     res.setHeader('Set-Cookie', serialize('adminizer_jwt', token, {
                         httpOnly: true,

package/controllers/media-manager/ThumbController.js

@@ -5,6 +5,6 @@ export async function thumbController(req, res) {
     const managerId = req.query.managerId;
     if (method === 'GET') {
         res.setHeader('Content-Type', 'image/webp');
-        res.send(await MediaManagerThumb.getThumb(id, managerId));
+        res.send(await MediaManagerThumb.getThumb(id, managerId, req.adminizer));
     }
 }

package/controllers/media-manager/mediaManagerAdapter.js

@@ -106,7 +106,7 @@ export class MediaManagerAdapter {
         });
     }
     checkDirectory() {
-        const outputDir = `${this.manager.fileStoragePath}/${this.manager.urlPathPrefix}`;
+        const outputDir = `${process.cwd()}/${this.manager.fileStoragePath}/${this.manager.urlPathPrefix}`;
         if (!fs.existsSync(outputDir)) {
             fs.mkdirSync(outputDir, { recursive: true });
         }

package/controllers/media-manager/mediaManagerApi.js

@@ -1,4 +1,3 @@
-import { MediaManagerHandler } from "../../lib/media-manager/MediaManagerHandler";
 import { MediaManagerAdapter } from "./mediaManagerAdapter";
 export async function mediaManagerController(req, res) {
     const method = req.method.toUpperCase();
@@ -16,7 +15,7 @@ export async function mediaManagerController(req, res) {
     if (!id) {
         return res.sendStatus(404);
     }
-    const _manager = MediaManagerHandler.get(id);
+    const _manager = req.adminizer.mediaManagerHandler.get(id);
     const manager = new MediaManagerAdapter(_manager);
     if (method === 'GET') {
         if (req.query._method === 'getLocales') {