adminizer 4.3.0-build.119 → 4.3.0-build.120

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);
@@ -62,7 +62,8 @@ export async function catalogController(req, res) {
                         });
                     }
                     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':
@@ -84,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";
+        data: any;
+    }>;
+    getEditTemplate(item: any, id: string | number, req: ReqType, modelId: string | number): Promise<{
+        type: "component" | "navigation.group" | "navigation.link" | "model";
+        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,7 +27,7 @@ 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;
@@ -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;
@@ -58,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);
@@ -71,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);
@@ -84,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.
@@ -95,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) {
@@ -111,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++;
         }
@@ -133,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);
         // Рекурсивно удаляем всех потомков
@@ -148,7 +165,7 @@ export class VueCatalog {
         return { ok: true };
     }
 }
-export class VueCatalogUtils {
+export class FrontendCatalogUtils {
     /**
      * Removes unnecessary data from the front
      */
@@ -156,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 {
@@ -186,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/lib/catalog/AbstractCatalog.js

@@ -269,7 +269,7 @@ export class AbstractCatalog {
                 const extras = await this.getChilds(item.id, undefined, req);
                 accumulator.push(...extras);
             }
-            if (item.parentId === 0)
+            if (item.parentId === null)
                 return item;
             const parentItem = await groupType._find(item.parentId, this.id);
             if (parentItem) {
@@ -285,7 +285,7 @@ export class AbstractCatalog {
             foundItems = foundItems.concat(items);
         }
         for (const item of foundItems) {
-            if (item.parentId !== 0) { // changed from null to 0
+            if (item.parentId !== null) { // changed from 0 to null
                 await buildTreeUpwards(item, hasExtras);
             }
         }
@@ -311,7 +311,7 @@ export class AbstractCatalog {
             itemMap[item.id] = item;
         });
         items.forEach(item => {
-            if (item.parentId === 0) { // changed from null to 0
+            if (item.parentId === null) {
                 tree.push(item);
             }
             else {

package/lib/catalog/Navigation.d.ts

@@ -1,7 +1,7 @@
 import { AbstractCatalog, ActionHandler, Item } from "./AbstractCatalog";
 import { NavigationConfig } from "../../interfaces/adminpanelConfig";
 import { Adminizer } from "../Adminizer";
-export interface NavItem extends Item {
+interface NavItem extends Item {
     urlPath?: string;
     modelId?: string | number;
     targetBlank?: boolean;
@@ -43,3 +43,4 @@ export declare class Navigation extends AbstractCatalog {
     constructor(adminizer: Adminizer, config: NavigationConfig);
     getIdList(): Promise<string[]>;
 }
+export {};

package/lib/catalog/Navigation.js

@@ -30,7 +30,7 @@ export class StorageService {
         return this.id;
     }
     async buildTree() {
-        const rootElements = await this.findElementsByParentId(0, null);
+        const rootElements = await this.findElementsByParentId(null, null);
         const buildSubTree = async (elements) => {
             const tree = [];
             for (const element of elements) {
@@ -56,9 +56,9 @@ export class StorageService {
         return tree;
     }
     async populateFromTree(tree) {
-        const traverseTree = async (node, parentId = 0) => {
+        const traverseTree = async (node, parentId = null) => {
             const { children, ...itemData } = node;
-            const item = { ...itemData, parentId };
+            const item = { ...itemData, parentId: itemData.parentId === 0 ? null : itemData.parentId };
             await this.setElement(item.id, item, true);
             if (children && children.length > 0) {
                 for (const child of children) {
@@ -109,6 +109,8 @@ export class StorageService {
     async findElementsByParentId(parentId, type) {
         const elements = [];
         for (const item of this.storageMap.values()) {
+            if (parentId === 0)
+                parentId = null;
             if (type === null && item.parentId === parentId) {
                 elements.push(item);
                 continue;
@@ -222,7 +224,9 @@ class NavigationItem extends AbstractItem {
     async dataPreparation(data, catalogId, sortOrder) {
         let storage = this.storageServices.get(catalogId);
         let urlPath = eval('`' + this.urlPath + '`');
-        let parentId = data.parentId ? data.parentId : 0; // changed from null to 0
+        let parentId = data.parentId ? data.parentId : null; // changed from 0 to null
+        if (parentId === 0)
+            parentId = null;
         return {
             id: uuid(),
             modelId: data.record.id,
@@ -332,7 +336,9 @@ class NavigationGroup extends AbstractGroup {
     }
     async dataPreparation(data, catalogId, sortOrder) {
         let storage = this.storageServices.get(catalogId);
-        let parentId = data.parentId ? data.parentId : 0; // changed from null to 0
+        let parentId = data.parentId ? data.parentId : null; // changed from 0 to null
+        if (parentId === 0)
+            parentId = null;
         return {
             id: uuid(),
             name: data.name,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "adminizer",
   "type": "module",
-  "version": "4.3.0-build.119",
+  "version": "4.3.0-build.120",
   "main": "index.js",
   "exports": {
     ".": "./index.js",