adminizer 4.1.0-commit.d8a06d3 → 4.1.1

package/lib/{catalog → v4/catalog}/AbstractCatalog.js

@@ -1,13 +1,14 @@
 /**
  * General Item structure that will be available for all elements, including groups
- *
- *
  */
 export class BaseItem {
     /**
      * Array of all global contexts, which will appear for all elements
      */
     actionHandlers;
+    /**
+     * Adds the context menu processor
+     */
     addActionHandler(contextHandler) {
         this.actionHandlers.push(contextHandler);
     }
@@ -19,13 +20,13 @@ export class BaseItem {
         item.icon = this.icon;
         item.type = this.type;
     }
-    async _find(itemId, catalogId) {
-        let item = await this.find(itemId, catalogId);
+    async _find(itemId, catalogId, req) {
+        let item = await this.find(itemId, catalogId, req);
         this._enrich(item);
         return item;
     }
-    async _getChilds(parentId, catalogId) {
-        let items = await this.getChilds(parentId, catalogId);
+    async _getChilds(parentId, catalogId, req) {
+        let items = await this.getChilds(parentId, catalogId, req);
         items.forEach((item) => {
             this._enrich(item);
         });
@@ -33,7 +34,6 @@ export class BaseItem {
     }
 }
 export class AbstractGroup extends BaseItem {
-    // public abstract create(itemId: string, data: T): Promise<T>;
     type = "group";
     isGroup = true;
     icon = "folder";
@@ -50,12 +50,12 @@ export class ActionHandler {
 }
 /**
  *
-    Abstract
-   ____    _  _____  _    _     ___   ____
-  / ___|  / \|_   _|/ \  | |   / _ \ / ___|
+ Abstract
+ ____    _  _____  _    _     ___   ____
+ / ___|  / \|_   _|/ \  | |   / _ \ / ___|
  | |     / _ \ | | / _ \ | |  | | | | |  _
  | |___ / ___ \| |/ ___ \| |__| |_| | |_| |
-  \____/_/   \_|_/_/   \_|_____\___/ \____|
+ \____/_/   \_|_/_/   \_|_____\___/ \____|
 
 
  */
@@ -81,15 +81,15 @@ export class AbstractCatalog {
      * Method for getting childs elements
      * if pass null as parentId this root
      */
-    async getChilds(parentId, byItemType) {
+    async getChilds(parentId, byItemType, req) {
         if (byItemType) {
-            const items = await this.getItemType(byItemType)?._getChilds(parentId, this.id);
+            const items = await this.getItemType(byItemType)?._getChilds(parentId, this.id, req);
             return items ? items.sort((a, b) => a.sortOrder - b.sortOrder) : [];
         }
         else {
             let result = [];
             for (const itemType of this.itemTypes) {
-                const items = await itemType?._getChilds(parentId, this.id);
+                const items = await itemType?._getChilds(parentId, this.id, req);
                 if (items) {
                     result = result.concat(items);
                 }
@@ -119,6 +119,7 @@ export class AbstractCatalog {
     }
     /**
      * Gettind id list method
+     * @info This is a dummy method, please make realization in sub class
      */
     async getIdList() {
         return [];
@@ -139,31 +140,32 @@ export class AbstractCatalog {
     /**
      *  Get an element
      */
-    find(item) {
-        return this.getItemType(item.type)?._find(item.id, this.id);
+    async find(item, req) {
+        return await this.getItemType(item.type)?._find(item.id, this.id, req);
     }
     /**
      *  Removing an element
      */
-    deleteItem(type, id) {
-        try {
-            this.getItemType(type)?.deleteItem(id, this.id);
-        }
-        catch (e) {
-            throw e;
-        }
+    async deleteItem(type, id, req) {
+        await this.getItemType(type)?.deleteItem(id, this.id, req);
     }
     /**
-     * Receives HTML to update an element for projection into a popup
+     * Get edit template from an item type
+     * @param item
+     * @param id
+     * @param req
+     * @param modelId
      */
-    getEditHTML(item, id, req, modelId) {
-        return this.getItemType(item.type)?.getEditHTML(id, this.id, req, modelId);
+    getEditTemplate(item, id, req, modelId) {
+        return this.getItemType(item.type)?.getEditTemplate(id, this.id, req, modelId);
     }
     /**
-     * Receives HTML to create an element for projection into a popup
+     * Get add template from an item type
+     * @param item
+     * @param req
      */
-    getAddHTML(item, req) {
-        return this.getItemType(item.type)?.getAddHTML(req);
+    getAddTemplate(item, req) {
+        return this.getItemType(item.type)?.getAddTemplate(req);
     }
     addActionHandler(actionHandler) {
         if (actionHandler.selectedItemTypes.length > 0) {
@@ -179,7 +181,7 @@ export class AbstractCatalog {
      * Method for getting group elements
      * If there are several Items, then the global ones will be obtained
      */
-    async getActions(items) {
+    getActions(items) {
         if (items.length === 1) {
             const item = items[0];
             const itemType = this.itemTypes.find((it) => it.type === item.type);
@@ -190,26 +192,23 @@ export class AbstractCatalog {
         }
     }
     /**
-     * Implements search and execution of a specific action.handler
+     * Implements search and execution of a specific action handler
      */
-    async handleAction(actionId, items, config) {
+    async handleAction(actionId, items, data, req) {
         let action = null;
         if (items.length === 1) {
             const item = items[0];
             const itemType = this.itemTypes.find((it) => it.type === item.type);
-            if (itemType.actionHandlers?.length) {
+            if (itemType && itemType.actionHandlers && itemType.actionHandlers.length) {
                 action = itemType.actionHandlers.find((it) => it.id === actionId);
             }
-            else {
-                action = this.actionHandlers.find((it) => it.id === actionId);
-            }
         }
-        else {
+        if (!action) {
             action = this.actionHandlers.find((it) => it.id === actionId);
         }
         if (!action)
             throw `Action with id \`${actionId}\` not found`;
-        return await action.handler(items, config);
+        return await action.handler(items, data, req);
     }
     /**
      * Only For a Link action
@@ -219,39 +218,45 @@ export class AbstractCatalog {
         return this.actionHandlers.find((it) => it.id === actionId)?.getLink();
     }
     /**
-     * For Extermal and JsonForms actions
+     * For Extermal and actions
      * @param actionId
+     * @param req
      */
-    async getPopUpHTML(actionId) {
-        return this.actionHandlers.find((it) => it.id === actionId)?.getPopUpHTML();
+    async getPopUpTemplate(actionId, req) {
+        return this.actionHandlers.find((it) => it.id === actionId)?.getPopUpTemplate(req);
     }
     /**
      *
      * @param data
+     * @param req
      */
-    createItem(data) {
-        return this.getItemType(data.type)?.create(data, this.id);
+    async createItem(data, req) {
+        const promise = this.getItemType(data.type)?.create(data, this.id, req);
+        return await promise;
     }
-    updateItem(id, type, data) {
-        return this.getItemType(type)?.update(id, data, this.id);
+    async updateItem(id, type, data, req) {
+        const promise = this.getItemType(type)?.update(id, data, this.id, req);
+        return await promise;
     }
     /**
      * To update all items in the tree after updating the model
-     * @param id
+     * @param modelId
      * @param type
      * @param data
+     * @param req
      */
-    updateModelItems(modelId, type, data) {
-        return this.getItemType(type)?.updateModelItems(modelId, data, this.id);
+    async updateModelItems(modelId, type, data, req) {
+        const promise = this.getItemType(type)?.updateModelItems(modelId, data, this.id, req);
+        return await promise;
     }
     /**
      * Method for getting group elements
      */
     getitemTypes() {
-        return this.itemTypes;
+        return this.itemTypes.map(({ adminizer, ...rest }) => rest);
     }
     ;
-    async search(s, hasExtras = true) {
+    async search(s, hasExtras = true, req) {
         // Build the trees for all found items
         const accumulator = [];
         // Find group type
@@ -260,10 +265,10 @@ export class AbstractCatalog {
         const buildTreeUpwards = async (item, hasExtras) => {
             // Add extras
             if (hasExtras) {
-                const extras = await this.getChilds(item.id);
+                const extras = await this.getChilds(item.id, undefined, req);
                 accumulator.push(...extras);
             }
-            if (item.parentId === null)
+            if (item.parentId === 0)
                 return item;
             const parentItem = await groupType._find(item.parentId, this.id);
             if (parentItem) {
@@ -279,7 +284,7 @@ export class AbstractCatalog {
             foundItems = foundItems.concat(items);
         }
         for (const item of foundItems) {
-            if (item.parentId !== null) {
+            if (item.parentId !== 0) { // changed from null to 0
                 await buildTreeUpwards(item, hasExtras);
             }
         }
@@ -305,7 +310,7 @@ export class AbstractCatalog {
             itemMap[item.id] = item;
         });
         items.forEach(item => {
-            if (item.parentId === null) {
+            if (item.parentId === 0) { // changed from null to 0
                 tree.push(item);
             }
             else {

package/lib/v4/catalog/Navigation.d.ts

@@ -0,0 +1,43 @@
+import { AbstractCatalog, ActionHandler, Item } from "./AbstractCatalog";
+import { NavigationConfig } from "../../../interfaces/adminpanelConfig";
+import { Adminizer } from "../../Adminizer";
+export interface NavItem extends Item {
+    urlPath?: string;
+    modelId?: string | number;
+    targetBlank?: boolean;
+}
+declare class StorageService {
+    protected storageMap: Map<string | number, NavItem>;
+    protected id: string;
+    protected model: string;
+    protected readonly adminizer: Adminizer;
+    constructor(adminizer: Adminizer, id: string, model: string);
+    protected initModel(): Promise<void>;
+    getId(): string;
+    buildTree(): Promise<any>;
+    populateFromTree(tree: any[]): Promise<void>;
+    setElement(id: string | number, item: NavItem, init?: boolean): Promise<NavItem>;
+    removeElementById(id: string | number): Promise<void>;
+    findElementById(id: string | number): Promise<NavItem | undefined>;
+    findElementByModelId(modelId: string | number): Promise<NavItem[] | undefined>;
+    saveToDB(): Promise<void>;
+    findElementsByParentId(parentId: string | number, type: string | null): Promise<NavItem[]>;
+    getAllElements(): Promise<NavItem[]>;
+    search(s: string, type: string): Promise<NavItem[]>;
+}
+export declare class StorageServices {
+    protected static storages: StorageService[];
+    static add(storage: StorageService): void;
+    static get(id: string): StorageService;
+    static getAll(): StorageService[];
+}
+export declare class Navigation extends AbstractCatalog {
+    readonly name: string;
+    readonly slug: string;
+    readonly icon: string;
+    readonly actionHandlers: ActionHandler[];
+    idList: string[];
+    constructor(adminizer: Adminizer, config: NavigationConfig);
+    getIdList(): Promise<string[]>;
+}
+export {};