adminizer 4.1.0-commit.ad1476a → 4.1.1

package/lib/{catalog → v4/catalog}/AbstractCatalog.d.ts

@@ -1,5 +1,4 @@
-import { JSONSchema4 } from "json-schema";
-import { Adminizer } from "../Adminizer";
+import { Adminizer } from "../../Adminizer";
 /**
  * Interface `Item` describes the data that the UI will operate on
  * This is a common interface for all data that is linked to the catalog
@@ -8,7 +7,10 @@ import { Adminizer } from "../Adminizer";
 export interface Item {
     id: string | number;
     name: string;
-    parentId: string | number | null;
+    parentId: string | number;
+    /**
+     *
+     */
     childs?: Item[];
     sortOrder: number;
     icon: string;
@@ -20,8 +22,6 @@ export type _Item_ = {
 };
 /**
  * General Item structure that will be available for all elements, including groups
- *
- *
  */
 export declare abstract class BaseItem<T extends Item> {
     abstract readonly type: string;
@@ -30,6 +30,7 @@ export declare abstract class BaseItem<T extends Item> {
      * I haven't found an easier way to extract this type that goes into generic
      * If you know how to open PR
      * */
+    abstract adminizer: Adminizer;
     /**
      * Catalog name
      */
@@ -50,46 +51,62 @@ export declare abstract class BaseItem<T extends Item> {
      * Array of all global contexts, which will appear for all elements
      */
     readonly actionHandlers: ActionHandler[];
+    /**
+     * Adds the context menu processor
+     */
     addActionHandler(contextHandler: ActionHandler): void;
     /**
      * Adds the required fields
      * @param item
      */
     _enrich(item: T): void;
-    _find(itemId: string | number, catalogId: string): Promise<T>;
-    abstract find(itemId: string | number, catalogId: string): Promise<T>;
+    _find(itemId: string | number, catalogId: string, req?: ReqType): Promise<T>;
+    abstract find(itemId: string | number, catalogId: string, req?: ReqType): Promise<T>;
     /**
      * Is false because default value Group is added
      */
-    abstract update(itemId: string | number, data: T, catalogId: string): Promise<T>;
+    abstract update(itemId: string | number, data: T, catalogId: string, req?: ReqType): Promise<T>;
     /**
      *
-     * @param itemId
+     * @param modelId
      * @param data
      * @param catalogId
+     * @param req
      */
-    abstract updateModelItems(modelId: string | number, data: any, catalogId: string): Promise<T>;
+    abstract updateModelItems(modelId: string | number, data: any, catalogId: string, req?: ReqType): Promise<T>;
     /**
-     * For custom HTML
-     * @param itemId
+     * Create catalog
      * @param data
+     * @param catalogId
+     * @param req
      */
-    abstract create(data: T, catalogId: string): Promise<T>;
+    abstract create(data: T, catalogId: string, req?: ReqType): Promise<T>;
     /**
      *  delete element
      */
-    abstract deleteItem(itemId: string | number, catalogId: string): Promise<void>;
-    abstract getAddHTML(req: ReqType): Promise<{
-        type: 'link' | 'html' | 'jsonForm';
-        data: string;
+    abstract deleteItem(itemId: string | number, catalogId: string, req?: ReqType): Promise<void>;
+    /**
+     * get add template
+     * @param req
+     */
+    abstract getAddTemplate(req: ReqType): Promise<{
+        type: 'component' | 'navigation.group' | 'navigation.link' | 'model';
+        data: any;
     }>;
-    abstract getEditHTML(id: string | number, catalogId: string, req: ReqType, modelId?: string | number): Promise<{
-        type: 'link' | 'html' | 'jsonForm';
-        data: string;
+    /**
+     * get edit template
+     * @param id
+     * @param catalogId
+     * @param req
+     * @param modelId
+     */
+    abstract getEditTemplate(id: string | number, catalogId: string, req: ReqType, modelId?: string | number): Promise<{
+        type: 'component' | 'navigation.group' | 'navigation.link' | 'model';
+        data: any;
     }>;
-    _getChilds(parentId: string | number | null, catalogId: string): Promise<Item[]>;
-    abstract getChilds(parentId: string | number | null, catalogId: string): Promise<Item[]>;
-    abstract search(s: string, catalogId: string): Promise<T[]>;
+    _getChilds(parentId: string | number, catalogId: string, req?: ReqType): Promise<Item[]>;
+    abstract getChilds(parentId: string | number, catalogId: string, req?: ReqType): Promise<Item[]>;
+    abstract search(s: string, catalogId: string, req?: ReqType): Promise<T[]>;
 }
 export declare abstract class AbstractGroup<T extends Item> extends BaseItem<T> {
     readonly type: string;
@@ -104,7 +121,7 @@ export declare abstract class ActionHandler {
      * Three actions are possible, without configuration, configuration via pop-up, and just external action
      * For the first two, a handler is provided, but the third type of action simply calls the HTML in the popup; the controller will be implemented externally
      * */
-    abstract readonly type: "basic" | "json-forms" | "external" | "link" | "partial";
+    abstract readonly type: "basic" | "external" | "link";
     /**
      * Will be shown in the context menu section
      */
@@ -113,16 +130,10 @@ export declare abstract class ActionHandler {
      * Will be shown in the toolbox section
      */
     abstract readonly displayTool: boolean;
-    /** (!*1)
-     * Only for json-forms
-     * ref: https://jsonforms.io/docs
-     */
-    abstract readonly uiSchema: any;
-    abstract readonly jsonSchema: JSONSchema4;
     /**
-     * For "json-forms" | "external"
+     * For "external"
      */
-    abstract getPopUpHTML(data?: any): Promise<string>;
+    abstract getPopUpTemplate(req?: ReqType): Promise<string>;
     /**
      * Only for link type
      */
@@ -141,18 +152,19 @@ export declare abstract class ActionHandler {
      * Implementation of a method that will do something with elements.
      * there's really not much you can do with the context menu
      * @param items
-     * @param config
+     * @param data
+     * @param req
      */
-    abstract handler(items: Item[], data?: any): Promise<void>;
+    abstract handler(items: Item[], data?: any, req?: ReqType): Promise<void | string>;
 }
 /**
  *
-    Abstract
-   ____    _  _____  _    _     ___   ____
-  / ___|  / \|_   _|/ \  | |   / _ \ / ___|
+ Abstract
+ ____    _  _____  _    _     ___   ____
+ / ___|  / \|_   _|/ \  | |   / _ \ / ___|
  | |     / _ \ | | / _ \ | |  | | | | |  _
  | |___ / ___ \| |/ ___ \| |__| |_| | |_| |
-  \____/_/   \_|_/_/   \_|_____\___/ \____|
+ \____/_/   \_|_/_/   \_|_____\___/ \____|
 
 
  */
@@ -190,12 +202,13 @@ export declare abstract class AbstractCatalog {
      * Method for getting childs elements
      * if pass null as parentId this root
      */
-    getChilds(parentId: string | number | null, byItemType?: string): Promise<Item[]>;
+    getChilds(parentId: string | number, byItemType?: string, req?: ReqType): Promise<Item[]>;
     private _bindAccessRight;
     protected constructor(adminizer: Adminizer, items: BaseItem<any>[]);
     setId(id: string): void;
     /**
      * Gettind id list method
+     * @info This is a dummy method, please make realization in sub class
      */
     getIdList(): Promise<string[]>;
     getItemType(type: string): BaseItem<Item>;
@@ -204,62 +217,78 @@ export declare abstract class AbstractCatalog {
     /**
      *  Get an element
      */
-    find(item: Item): Promise<Item>;
+    find(item: Item, req?: ReqType): Promise<Item>;
     /**
      *  Removing an element
      */
-    deleteItem(type: string, id: string | number): void;
+    deleteItem(type: string, id: string | number, req?: ReqType): Promise<void>;
     /**
-     * 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: Item, id: string | number, req: ReqType, modelId?: string | number): Promise<{
-        type: "link" | "html" | "jsonForm";
-        data: string;
+    getEditTemplate(item: Item, id: string | number, req: ReqType, modelId?: string | number): Promise<{
+        type: "component" | "navigation.group" | "navigation.link" | "model";
+        data: any;
     }>;
     /**
-     * Receives HTML to create an element for projection into a popup
+     * Get add template from an item type
+     * @param item
+     * @param req
      */
-    getAddHTML(item: Item, req: ReqType): Promise<{
-        type: "link" | "html" | "jsonForm";
-        data: string;
+    getAddTemplate(item: Item, req: ReqType): Promise<{
+        type: "component" | "navigation.group" | "navigation.link" | "model";
+        data: any;
     }>;
     addActionHandler(actionHandler: ActionHandler): void;
     /**
      * Method for getting group elements
      * If there are several Items, then the global ones will be obtained
      */
-    getActions(items?: Item[]): Promise<ActionHandler[]>;
+    getActions(items?: Item[]): ActionHandler[];
     /**
-     * Implements search and execution of a specific action.handler
+     * Implements search and execution of a specific action handler
      */
-    handleAction(actionId: string, items?: Item[], config?: any): Promise<void>;
+    handleAction(actionId: string, items?: Item[], data?: any, req?: ReqType): Promise<void | string>;
     /**
      * Only For a Link action
      * @param actionId
      */
     getLink(actionId: string): Promise<string>;
     /**
-     * For Extermal and JsonForms actions
+     * For Extermal and actions
      * @param actionId
+     * @param req
      */
-    getPopUpHTML(actionId: string): Promise<string>;
+    getPopUpTemplate(actionId: string, req?: ReqType): Promise<string>;
     /**
      *
      * @param data
+     * @param req
      */
-    createItem<T extends Item>(data: T): Promise<T>;
-    updateItem<T extends Item>(id: string | number, type: string, data: T): Promise<T>;
+    createItem<T extends Item>(data: T, req?: ReqType): Promise<T>;
+    updateItem<T extends Item>(id: string | number, type: string, data: T, req?: ReqType): Promise<T>;
     /**
      * To update all items in the tree after updating the model
-     * @param id
+     * @param modelId
      * @param type
      * @param data
+     * @param req
      */
-    updateModelItems<T extends Item>(modelId: string | number, type: string, data: T): Promise<T>;
+    updateModelItems<T extends Item>(modelId: string | number, type: string, data: T, req?: ReqType): Promise<T>;
     /**
      * Method for getting group elements
      */
-    getitemTypes(): BaseItem<Item>[];
-    search<T extends Item>(s: string, hasExtras?: boolean): Promise<T[]>;
+    getitemTypes(): {
+        type: string;
+        name: string;
+        isGroup: boolean;
+        allowedRoot: boolean;
+        icon: string;
+        actionHandlers: ActionHandler[];
+    }[];
+    search<T extends Item>(s: string, hasExtras?: boolean, req?: ReqType): Promise<T[]>;
     static buildTree(items: Item[]): Item[];
 }

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,27 +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);
         }
-        // console.log(this.actionHandlers)
         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
@@ -220,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
@@ -261,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) {
@@ -280,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);
             }
         }
@@ -306,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 {};