adminizer 4.1.0-build.26 → 4.1.0-build.28

package/lib/v4/catalog/Navigation.js

@@ -0,0 +1,462 @@
+import { AbstractCatalog, AbstractGroup, AbstractItem } from "./AbstractCatalog";
+import { v4 as uuid } from "uuid";
+import { Adminizer } from "../../Adminizer";
+class StorageService {
+    storageMap = new Map();
+    id;
+    model;
+    adminizer;
+    constructor(adminizer, id, model) {
+        this.adminizer = adminizer;
+        this.id = id;
+        this.model = model.toLowerCase();
+        this.initModel();
+    }
+    async initModel() {
+        // Direct call by model adapter
+        const navigation = await this.adminizer.modelHandler.model.get(this.model)["_findOne"]({ label: this.id });
+        if (navigation) {
+            Adminizer.log.info(`Found existing navigation: ${this.id}`);
+            await this.populateFromTree(navigation.tree);
+        }
+        else {
+            const newNavigation = { label: this.id, tree: [] };
+            // Direct call by model adapter
+            await this.adminizer.modelHandler.model.get(this.model)["_create"](newNavigation);
+            Adminizer.log.info(`Created a new navigation: ${this.id}`);
+        }
+    }
+    getId() {
+        return this.id;
+    }
+    async buildTree() {
+        const rootElements = await this.findElementsByParentId(null, null);
+        const buildSubTree = async (elements) => {
+            const tree = [];
+            for (const element of elements) {
+                const children = await this.findElementsByParentId(element.id, null);
+                tree.push({
+                    ...element,
+                    children: await buildSubTree(children)
+                });
+            }
+            return tree;
+        };
+        let tree = await buildSubTree(rootElements);
+        function sortTree(items) {
+            items.sort((a, b) => a.sortOrder - b.sortOrder);
+            for (let i = 0; i < items.length; i++) {
+                const item = items[i];
+                if (item.children) {
+                    sortTree(item.children);
+                }
+            }
+        }
+        sortTree(tree);
+        return tree;
+    }
+    async populateFromTree(tree) {
+        const traverseTree = async (node, parentId = null) => {
+            const { children, ...itemData } = node;
+            const item = { ...itemData, parentId };
+            await this.setElement(item.id, item);
+            if (children && children.length > 0) {
+                for (const child of children) {
+                    await traverseTree(child, item.id);
+                }
+            }
+        };
+        for (const node of tree) {
+            await traverseTree(node);
+        }
+    }
+    async setElement(id, item) {
+        this.storageMap.set(item.id, item);
+        await this.saveToDB();
+        // This like fetch in DB
+        return this.findElementById(item.id);
+    }
+    async removeElementById(id) {
+        this.storageMap.delete(id);
+        setTimeout(async () => {
+            await this.saveToDB();
+        }, 500);
+    }
+    async findElementById(id) {
+        return this.storageMap.get(id);
+    }
+    async findElementByModelId(modelId) {
+        const elements = [];
+        for (const item of this.storageMap.values()) {
+            if (item.modelId === modelId) {
+                elements.push(item);
+            }
+        }
+        return elements;
+    }
+    async saveToDB() {
+        let tree = await this.buildTree();
+        console.log({ label: this.id }, { tree: tree });
+        try {
+            // Direct call by model adapter
+            await this.adminizer.modelHandler.model.get(this.model)["_update"]({ label: this.id }, { tree: tree });
+        }
+        catch (e) {
+            console.log(e);
+            throw 'navigation model update error';
+        }
+    }
+    async findElementsByParentId(parentId, type) {
+        const elements = [];
+        for (const item of this.storageMap.values()) {
+            if (type === null && item.parentId === parentId) {
+                elements.push(item);
+                continue;
+            }
+            if (item.parentId === parentId && item.type === type) {
+                elements.push(item);
+            }
+        }
+        return elements;
+    }
+    async getAllElements() {
+        return Array.from(this.storageMap.values());
+    }
+    async search(s, type) {
+        const lowerCaseQuery = s.toLowerCase(); // Convert query to lowercase for case-insensitive search
+        const matchedElements = [];
+        for (const item of this.storageMap.values()) {
+            // Check if item type matches the specified type
+            if (item.type === type) {
+                // Search by name
+                if (item.name.toLowerCase().includes(lowerCaseQuery)) {
+                    matchedElements.push(item);
+                }
+            }
+        }
+        return matchedElements;
+    }
+}
+export class StorageServices {
+    static storages = [];
+    static add(storage) {
+        this.storages.push(storage);
+    }
+    static get(id) {
+        return this.storages.find(storage => storage.getId() === id);
+    }
+    static getAll() {
+        return this.storages;
+    }
+}
+export class Navigation extends AbstractCatalog {
+    name = 'Navigation';
+    slug = 'navigation';
+    icon = "box";
+    actionHandlers = [];
+    idList = [];
+    constructor(adminizer, config) {
+        let items = [];
+        for (const configElement of config.items) {
+            items.push(new NavigationItem(adminizer, configElement.title, configElement.model, config.model, configElement.urlPath));
+        }
+        items.push(new NavigationGroup(adminizer, config.groupField));
+        items.push(new LinkItem(adminizer));
+        for (const section of config.sections) {
+            StorageServices.add(new StorageService(adminizer, section, config.model));
+        }
+        super(adminizer, items);
+        this.movingGroupsRootOnly = config.movingGroupsRootOnly;
+        this.idList = config.sections ?? [];
+    }
+    async getIdList() {
+        return this.idList;
+    }
+}
+class NavigationItem extends AbstractItem {
+    allowedRoot = true;
+    icon;
+    name;
+    type;
+    model;
+    navigationModel;
+    actionHandlers = [];
+    urlPath;
+    adminizer;
+    constructor(adminizer, name, model, navigationModel, urlPath) {
+        super();
+        this.name = name;
+        this.navigationModel = navigationModel;
+        this.model = model.toLowerCase();
+        this.type = model.toLowerCase();
+        this.urlPath = urlPath;
+        let configModel = adminizer.config.models[this.model];
+        this.icon = configModel?.icon ?? 'file';
+        this.adminizer = adminizer;
+    }
+    async create(data, catalogId) {
+        let storage = StorageServices.get(catalogId);
+        let storageData = null;
+        if (data._method === 'select') {
+            // Direct call by model adapter
+            let record = await this.adminizer.modelHandler.model.get(this.model)["_findOne"]({ id: data.record });
+            storageData = await this.dataPreparation({
+                record: record,
+                parentId: data.parentId,
+                targetBlank: data.targetBlank
+            }, catalogId);
+        }
+        else {
+            storageData = await this.dataPreparation(data, catalogId);
+        }
+        return await storage.setElement(data.id, storageData);
+    }
+    async dataPreparation(data, catalogId, sortOrder) {
+        let storage = StorageServices.get(catalogId);
+        let urlPath = eval('`' + this.urlPath + '`');
+        let parentId = data.parentId ? data.parentId : 0; // changed from null to 0
+        return {
+            id: uuid(),
+            modelId: data.record.id,
+            targetBlank: data.targetBlank ?? data.record.targetBlank,
+            name: data.record.name ?? data.record.title ?? data.record.id,
+            parentId: parentId,
+            sortOrder: sortOrder ?? (await storage.findElementsByParentId(parentId, null)).length,
+            icon: this.icon,
+            type: this.type,
+            urlPath: urlPath
+        };
+    }
+    async updateModelItems(modelId, data, catalogId) {
+        let storage = StorageServices.get(catalogId);
+        let items = await storage.findElementByModelId(modelId);
+        let urlPath = eval('`' + this.urlPath + '`');
+        for (const item of items) {
+            item.name = data.record.name;
+            item.urlPath = urlPath;
+            if (item.id === data.record.treeId) {
+                item.targetBlank = data.record.targetBlank;
+            }
+            await storage.setElement(item.id, item);
+        }
+        return Promise.resolve(undefined);
+    }
+    async update(itemId, data, catalogId) {
+        let storage = StorageServices.get(catalogId);
+        return await storage.setElement(itemId, data);
+    }
+    async deleteItem(itemId, catalogId) {
+        let storage = StorageServices.get(catalogId);
+        return await storage.removeElementById(itemId);
+    }
+    async find(itemId, catalogId) {
+        let storage = StorageServices.get(catalogId);
+        return await storage.findElementById(itemId);
+    }
+    /**
+     * @deprecated reason: migration for intertia
+    * // TODO: need passing custom React module
+    */
+    async getAddHTML(req) {
+        let type = 'navigation.item';
+        // Direct call by model adapter
+        let itemsDB = await this.adminizer.modelHandler.model.get(this.model)["_find"]({});
+        let items = itemsDB.map((item) => {
+            return {
+                id: item.id,
+                name: item.name ?? item.title ?? item.id
+            };
+        });
+        return {
+            type: type,
+            data: {
+                items: items,
+                model: this.model,
+                labels: {
+                    selectTitle: `${req.i18n.__('Select')} ${req.i18n.__(this.name + 's')}`,
+                    createTitle: `${req.i18n.__('create new')} ${req.i18n.__(this.name + 's')}`,
+                    OR: req.i18n.__('OR')
+                }
+            }
+        };
+    }
+    async getChilds(parentId, catalogId) {
+        let storage = StorageServices.get(catalogId);
+        return await storage.findElementsByParentId(parentId, this.type);
+    }
+    /**
+     * @deprecated reason: migration for intertia
+    * // TODO: need passing custom React module
+    */
+    async getEditHTML(id, catalogId, req, modelId) {
+        let item = await this.find(id, catalogId);
+        let type = 'html';
+        // This dirty hack is here because the field of view is disappearing
+        req.i18n.setLocale(req.user.locale);
+        const __ = (s) => {
+            return req.i18n.__(s);
+        };
+        return Promise.resolve({
+            type: type,
+            // data: ejs.render(fs.readFileSync(ViewsHelper.getViewPath('./../../views/ejs/navigation/itemHTMLEdit.ejs'), 'utf8'), {item: item, __: __})
+            data: ''
+        });
+    }
+    async search(s, catalogId) {
+        let storage = StorageServices.get(catalogId);
+        return await storage.search(s, this.type);
+    }
+}
+class NavigationGroup extends AbstractGroup {
+    allowedRoot = true;
+    name = "Group";
+    groupField;
+    adminizer;
+    constructor(adminizer, groupField) {
+        super();
+        this.groupField = groupField;
+        this.adminizer = adminizer;
+    }
+    async create(data, catalogId) {
+        let storage = StorageServices.get(catalogId);
+        let storageData = await this.dataPreparation(data, catalogId);
+        delete data.name;
+        delete data.parentId;
+        storageData = { ...storageData, ...data };
+        return await storage.setElement(storageData.id, storageData);
+    }
+    async dataPreparation(data, catalogId, sortOrder) {
+        let storage = StorageServices.get(catalogId);
+        let parentId = data.parentId ? data.parentId : 0; // changed from null to 0
+        return {
+            id: uuid(),
+            name: data.name,
+            targetBlank: data.targetBlank,
+            parentId: parentId,
+            sortOrder: sortOrder ?? (await storage.findElementsByParentId(parentId, null)).length,
+            icon: this.icon,
+            type: this.type
+        };
+    }
+    async deleteItem(itemId, catalogId) {
+        let storage = StorageServices.get(catalogId);
+        return await storage.removeElementById(itemId);
+    }
+    async find(itemId, catalogId) {
+        let storage = StorageServices.get(catalogId);
+        return await storage.findElementById(itemId);
+    }
+    async update(itemId, data, catalogId) {
+        let storage = StorageServices.get(catalogId);
+        return await storage.setElement(itemId, data);
+    }
+    async updateModelItems(modelId, data, catalogId) {
+        let storage = StorageServices.get(catalogId);
+        return await storage.setElement(modelId, data);
+    }
+    /**
+     * @deprecated reason: migration for intertia
+    * // TODO: need passing custom React module
+    */
+    getAddHTML(req) {
+        let type = 'navigation.group';
+        let resItems = [];
+        if (this.groupField.length) {
+            resItems = this.groupField.map((field) => {
+                return {
+                    name: field.name,
+                    required: field.required
+                };
+            });
+        }
+        return Promise.resolve({
+            type: type,
+            data: {
+                items: resItems,
+                labels: {
+                    openInNewWindow: req.i18n.__('Open in a new window'),
+                    title: req.i18n.__('Title'),
+                    save: req.i18n.__('Save')
+                }
+            }
+        });
+    }
+    async getChilds(parentId, catalogId) {
+        let storage = StorageServices.get(catalogId);
+        return await storage.findElementsByParentId(parentId, this.type);
+    }
+    /**
+     * @deprecated reason: migration for intertia
+    * // TODO: need passing custom React module
+    */
+    async getEditHTML(id, catalogId, req, modelId) {
+        let type = 'html';
+        let item = await this.find(id, catalogId);
+        // This dirty hack is here because the field of view is disappearing
+        req.i18n.setLocale(req.user.locale);
+        const __ = (s) => {
+            return req.i18n.__(s);
+        };
+        return Promise.resolve({
+            type: type,
+            // data: ejs.render(fs.readFileSync(ViewsHelper.getViewPath('./../../views/ejs/navigation/GroupHTMLEdit.ejs'), 'utf8'), {
+            // 	fields: this.groupField,
+            // 	item: item,
+            // 	__: __
+            // }),
+            data: ''
+        });
+    }
+    async search(s, catalogId) {
+        let storage = StorageServices.get(catalogId);
+        return await storage.search(s, this.type);
+    }
+}
+class LinkItem extends NavigationGroup {
+    allowedRoot = true;
+    icon = 'external-link-alt';
+    name = 'Link';
+    type = 'link';
+    isGroup = false;
+    constructor(adminizer) {
+        super(adminizer, []);
+    }
+    /**
+     * @deprecated reason: migration for intertia
+    * // TODO: need passing custom React module
+    */
+    // @ts-ignore
+    getAddHTML(req) {
+        let type = 'html';
+        req.i18n.setLocale(req.user.locale);
+        const __ = (s) => {
+            return req.i18n.__(s);
+        };
+        return Promise.resolve({
+            type: type,
+            // data: ejs.render(fs.readFileSync(ViewsHelper.getViewPath('./../../views/ejs/navigation/LinkItemAdd.ejs'), 'utf8'), {__: __}),
+            data: ''
+        });
+    }
+    /**
+     * @deprecated reason: migration for intertia
+    * // TODO: need passing custom React module
+    */
+    async getEditHTML(id, catalogId, req) {
+        let type = 'html';
+        let item = await this.find(id, catalogId);
+        req.i18n.setLocale(req.user.locale);
+        const __ = (s) => {
+            return req.i18n.__(s);
+        };
+        return Promise.resolve({
+            type: type,
+            // data: ejs.render(fs.readFileSync(ViewsHelper.getViewPath('./../../views/ejs/navigation/LinkItemEdit.ejs'), 'utf8'), {
+            // 	fields: this.groupField,
+            // 	item: item,
+            // 	__: __
+            // }),
+            data: ''
+        });
+    }
+}

package/lib/{controls → v4/controls}/AbstractControls.d.ts

@@ -1,4 +1,4 @@
-import { Adminizer } from "../Adminizer";
+import { Adminizer } from "../../Adminizer";
 export type ControlType = 'wysiwyg' | 'jsonEditor' | 'geoJson' | 'markdown' | 'table' | 'codeEditor';
 export interface Path {
     jsPath: {

package/lib/{controls → v4/controls}/codeEditor/MonacoEditor.d.ts

@@ -1,5 +1,5 @@
 import { AbstractControls, ControlType, Config, Path } from "../AbstractControls";
-import { Adminizer } from "../../Adminizer";
+import { Adminizer } from "../../../Adminizer";
 export declare class MonacoEditor extends AbstractControls {
     readonly config: Config;
     readonly name: string;

package/lib/{controls → v4/controls}/geojsoneditor/GeoEditor.d.ts

@@ -1,5 +1,5 @@
 import { AbstractControls, ControlType, Config, Path } from "../AbstractControls";
-import { Adminizer } from "../../Adminizer";
+import { Adminizer } from "../../../Adminizer";
 export declare class GeoEditor extends AbstractControls {
     readonly config: Config;
     readonly name: string;

package/lib/{controls → v4/controls}/jsoneditor/JsonEditor.d.ts

@@ -1,6 +1,6 @@
 import { AbstractControls, ControlType, Path, Config } from "../AbstractControls";
 import { EditorOptions } from "@toast-ui/editor/types/editor";
-import { Adminizer } from "../../Adminizer";
+import { Adminizer } from "../../../Adminizer";
 export declare class JsonEditor extends AbstractControls {
     readonly config: Partial<EditorOptions>;
     readonly name: string;

package/lib/{controls → v4/controls}/markdown/ToastUiEditor.d.ts

@@ -1,6 +1,6 @@
 import { AbstractControls, ControlType, Path, Config } from "../AbstractControls";
 import { EditorOptions } from "@toast-ui/editor/types/editor";
-import { Adminizer } from "../../Adminizer";
+import { Adminizer } from "../../../Adminizer";
 export declare class ToastUiEditor extends AbstractControls {
     readonly config: Partial<EditorOptions>;
     readonly name: string;

package/lib/{controls → v4/controls}/table/Handsontable.d.ts

@@ -1,5 +1,5 @@
 import { AbstractControls, ControlType, Config, Path } from "../AbstractControls";
-import { Adminizer } from "../../Adminizer";
+import { Adminizer } from "../../../Adminizer";
 export declare class Handsontable extends AbstractControls {
     readonly config: Config;
     readonly name: string;

package/lib/{controls → v4/controls}/wysiwyg/CKeditor.d.ts

@@ -1,5 +1,5 @@
 import { AbstractControls, ControlType, Config, Path } from "../AbstractControls";
-import { Adminizer } from "../../Adminizer";
+import { Adminizer } from "../../../Adminizer";
 export declare class CKeditor extends AbstractControls {
     readonly name: string;
     readonly type: ControlType;

package/lib/{datatable → v4/datatable}/NodeTable.d.ts

@@ -1,6 +1,6 @@
-import { Fields } from '../../helpers/fieldsHelper';
-import { AbstractModel } from '../v4/model/AbstractModel';
-import { DataAccessor } from "../v4/DataAccessor";
+import { Fields } from '../../../helpers/fieldsHelper';
+import { AbstractModel } from '../model/AbstractModel';
+import { DataAccessor } from "../DataAccessor";
 interface Request {
     start: string;
     length: string;

package/lib/v4/model/adapter/sequelize.js

@@ -99,7 +99,7 @@ export function mapSequelizeToWaterline(model) {
                 result[a.foreignKey]["primaryKeyForAssociation"] = true;
                 result[alias] = {
                     type: "association",
-                    model: a.target.name.toLowerCase(),
+                    model: a.target.name,
                     via: a.foreignKey,
                 };
                 break;
@@ -109,7 +109,7 @@ export function mapSequelizeToWaterline(model) {
                 result[a.foreignKey]["primaryKeyForAssociation"] = true;
                 result[alias] = {
                     type: "association",
-                    model: a.target.name.toLowerCase(),
+                    model: a.target.name,
                     via: a.foreignKey,
                 };
                 break;
@@ -118,7 +118,7 @@ export function mapSequelizeToWaterline(model) {
                 const a = assoc;
                 result[alias] = {
                     type: "association-many",
-                    collection: a.target.name.toLowerCase(),
+                    collection: a.target.name,
                     via: a.foreignKey,
                 };
                 break;
@@ -127,7 +127,7 @@ export function mapSequelizeToWaterline(model) {
                 const a = assoc;
                 result[alias] = {
                     type: "association-many",
-                    collection: a.target.name.toLowerCase(),
+                    collection: a.target.name,
                     via: a.otherKey,
                 };
                 break;

package/lib/{widgets → v4/widgets}/abstractLink.d.ts

@@ -1,5 +1,5 @@
 import BaseWidget from "./abstractWidgetBase";
-import { MaterialIcon } from "../../interfaces/MaaterialIcons";
+import { MaterialIcon } from "../../../interfaces/MaaterialIcons";
 export interface Links {
     name: string;
     description: string;

package/lib/{widgets → v4/widgets}/abstractWidgetBase.d.ts

@@ -1,4 +1,4 @@
-import { MaterialIcon } from "../../interfaces/MaaterialIcons";
+import { MaterialIcon } from "../../../interfaces/MaaterialIcons";
 export default abstract class BaseWidget {
     /** Widget unique id */
     abstract readonly id: string;

package/lib/{widgets → v4/widgets}/widgetHandler.d.ts

@@ -3,10 +3,10 @@ import InfoBase from "./abstractInfo";
 import ActionBase from "./abstractAction";
 import LinkBase from "./abstractLink";
 import CustomBase from "./abstractCustom";
-import { AdminpanelIcon } from "../../interfaces/adminpanelConfig";
-import { Adminizer } from "../Adminizer";
+import { AdminpanelIcon } from "../../../interfaces/adminpanelConfig";
+import { Adminizer } from "../../Adminizer";
 import { UserAP } from "models/UserAP";
-import { I18n } from "../v4/I18n";
+import { I18n } from "../I18n";
 export type WidgetType = (SwitcherBase | InfoBase | ActionBase | LinkBase | CustomBase);
 export interface WidgetConfig {
     id: string;

package/models/NavigationAP.d.ts

@@ -1,14 +1,13 @@
 declare const _default: {
     id: {
         type: string;
-        allowNull: boolean;
-        uuid: boolean;
+        autoIncrement: boolean;
         primaryKey: boolean;
-        required: boolean;
     };
     label: {
         type: string;
         required: boolean;
+        unique: boolean;
     };
     tree: {
         type: string;

package/models/NavigationAP.js

@@ -1,14 +1,13 @@
 export default {
     id: {
-        type: "string",
-        allowNull: false,
-        uuid: true,
-        primaryKey: true,
-        required: true
+        type: "number",
+        autoIncrement: true,
+        primaryKey: true
     },
     label: {
         type: "string",
-        required: true
+        required: true,
+        unique: true
     },
     tree: {
         type: "json",

package/models/UserAP.d.ts

@@ -1,4 +1,4 @@
-import { WidgetConfig, WidgetsLayouts } from "lib/widgets/widgetHandler";
+import { WidgetConfig, WidgetsLayouts } from "lib/v4/widgets/widgetHandler";
 import { GroupAP } from "./GroupAP";
 declare const _default: {
     id: {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "adminizer",
   "type": "module",
-  "version": "4.1.0-build.26",
+  "version": "4.1.0-build.28",
   "main": "index.js",
   "scripts": {
     "test": "vitest --reporter verbose",
@@ -27,6 +27,7 @@
   "license": "MIT",
   "description": "",
   "dependencies": {
+    "@minoru/react-dnd-treeview": "^3.5.2",
     "body-parser": "^1.20.3",
     "chalk": "^5.4.1",
     "cmdk": "^1.1.1",
@@ -42,6 +43,7 @@
     "multer": "^1.4.5-lts.1",
     "next-themes": "^0.4.6",
     "password-hash": "^1.2.2",
+    "react-dnd": "^16.0.1",
     "sharp": "^0.33.5",
     "typeorm": "^0.3.20",
     "uuid": "^11.0.5",

package/system/Router.js

@@ -66,8 +66,8 @@ export default class Router {
         /**
          * Catalog
          */
-        adminizer.app.all(`/catalog/:slug/:id`, adminizer.policyManager.bindPolicies(policies, catalogController));
-        adminizer.app.all(`/catalog/:slug`, adminizer.policyManager.bindPolicies(policies, catalogController));
+        adminizer.app.all(`${adminizer.config.routePrefix}/catalog/:slug/:id`, adminizer.policyManager.bindPolicies(policies, catalogController));
+        adminizer.app.all(`${adminizer.config.routePrefix}/catalog/:slug`, adminizer.policyManager.bindPolicies(policies, catalogController));
         /**
          * Media Manager
          */