adminizer 4.1.0-commit.d8a06d3 → 4.1.1

package/lib/v4/catalog/Navigation.js

@@ -0,0 +1,457 @@
+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(0, 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 = 0) => {
+            const { children, ...itemData } = node;
+            const item = { ...itemData, parentId };
+            await this.setElement(item.id, item, true);
+            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, init = false) {
+        this.storageMap.set(item.id, item);
+        if (!init)
+            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();
+        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;
+        this.type = model.toLowerCase();
+        this.urlPath = urlPath;
+        let configModel = adminizer.config.models[this.model];
+        this.icon = configModel?.icon ?? 'file_present';
+        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 + '`');
+        let response = [];
+        for (const item of items) {
+            item.name = data.record.name ?? data.record.title ?? data.record.id;
+            item.urlPath = urlPath;
+            if (item.id === data.record.treeId) {
+                item.targetBlank = data.record.targetBlank;
+            }
+            response.push(await storage.setElement(item.id, item));
+        }
+        return response[0];
+    }
+    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 getAddTemplate(req) {
+        let type = 'model';
+        // 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'),
+                    openInNewWindow: req.i18n.__('Open in a new window'),
+                }
+            }
+        };
+    }
+    async getChilds(parentId, catalogId) {
+        let storage = StorageServices.get(catalogId);
+        return await storage.findElementsByParentId(parentId, this.type);
+    }
+    async getEditTemplate(id, catalogId, req, modelId) {
+        return Promise.resolve({
+            type: 'model',
+            data: {
+                item: await this.find(id, catalogId)
+            }
+        });
+    }
+    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);
+    }
+    getAddTemplate(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 getEditTemplate(id, catalogId, req, modelId) {
+        let item = await this.find(id, catalogId);
+        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,
+                item: item,
+                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);
+    }
+    async search(s, catalogId) {
+        let storage = StorageServices.get(catalogId);
+        return await storage.search(s, this.type);
+    }
+}
+class LinkItem extends NavigationGroup {
+    allowedRoot = true;
+    icon = 'insert_link';
+    name = 'Link';
+    type = 'link';
+    isGroup = false;
+    constructor(adminizer) {
+        super(adminizer, []);
+    }
+    getAddTemplate(req) {
+        let type = 'navigation.link';
+        let resItems = [
+            {
+                name: req.i18n.__('Link'),
+                required: true
+            }
+        ];
+        return Promise.resolve({
+            type: type,
+            data: {
+                items: resItems,
+                labels: {
+                    title: req.i18n.__('Title'),
+                    openInNewWindow: req.i18n.__('Open in a new window'),
+                    save: req.i18n.__('Save')
+                }
+            }
+        });
+    }
+    async getEditTemplate(id, catalogId, req) {
+        let item = await this.find(id, catalogId);
+        let type = 'navigation.group';
+        let resItems = [
+            {
+                name: req.i18n.__('Link'),
+                required: true
+            }
+        ];
+        return Promise.resolve({
+            type: type,
+            data: {
+                items: resItems,
+                item: item,
+                labels: {
+                    openInNewWindow: req.i18n.__('Open in a new window'),
+                    title: req.i18n.__('Title'),
+                    save: req.i18n.__('Save')
+                }
+            }
+        });
+    }
+}

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/{datatable → v4/datatable}/NodeTable.js

@@ -131,8 +131,8 @@ export class NodeTable {
     async output(callback, dataAccessor) {
         try {
             const queryOptions = await this.buildQuery();
-            const totalRecords = await this.model.count({});
-            const filteredRecords = await this.model.count(queryOptions.where);
+            const totalRecords = await this.model.count({}, dataAccessor);
+            const filteredRecords = await this.model.count(queryOptions.where, dataAccessor);
             const data = await this.model.find(queryOptions, dataAccessor);
             const output = {
                 draw: this.request.draw !== "" ? this.request.draw : 0,
@@ -160,6 +160,9 @@ export class NodeTable {
             Object.keys(this.fields).forEach((key) => {
                 let fieldConfigConfig = this.fields[key].config;
                 let fieldName = key;
+                let displayField = this.fields[key].modelConfig?.titleField ?? typeof row["title"] !== "undefined" ? 'title'
+                    : typeof row["name"] !== "undefined" ? 'name'
+                        : typeof row[this.fields[key].modelConfig?.identifierField] !== "undefined" ? this.fields[key].modelConfig?.identifierField : this.fields[key].modelConfig?.identifierField;
                 if (fieldConfigConfig.displayModifier) {
                     row[fieldName] = fieldConfigConfig.displayModifier(elem[key]);
                 }
@@ -169,7 +172,7 @@ export class NodeTable {
                         row[fieldName] = null;
                     }
                     else {
-                        row[fieldName] = elem[key][fieldConfigConfig.displayField];
+                        row[fieldName] = elem[key][displayField];
                     }
                 }
                 else if (this.fields[key].model.type === "association-many" || this.fields[key].model.type === "association") {
@@ -179,8 +182,8 @@ export class NodeTable {
                     else {
                         let displayValues = [];
                         elem[key].forEach((item) => {
-                            if (item[fieldConfigConfig.displayField]) {
-                                displayValues.push(item[fieldConfigConfig.displayField]);
+                            if (item[displayField]) {
+                                displayValues.push(item[displayField]);
                             }
                             else {
                                 displayValues.push(item[fieldConfigConfig.identifierField]);

package/lib/v4/model/AbstractModel.d.ts

@@ -10,6 +10,10 @@ export interface Attribute {
     collection?: string;
     via?: string;
     allowNull?: boolean;
+    /**
+     * This is a field that indicates that it refers to keep the bond key 1: 1
+     */
+    primaryKeyForAssociation?: boolean;
 }
 export interface ModelAttributes {
     [key: string]: Attribute;
@@ -49,7 +53,7 @@ export declare abstract class AbstractModel<T> {
     update(criteria: Partial<T>, data: Partial<T>, dataAccessor: DataAccessor): Promise<Partial<T>[]>;
     destroyOne(criteria: Partial<T>, dataAccessor: DataAccessor): Promise<Partial<T> | null>;
     destroy(criteria: Partial<T>, dataAccessor: DataAccessor): Promise<Partial<T>[]>;
-    count(criteria: Partial<T> | undefined): Promise<number>;
+    count(criteria: Partial<T> | undefined, dataAccessor: DataAccessor): Promise<number>;
 }
 export declare abstract class AbstractAdapter {
     abstract Model: any;

package/lib/v4/model/AbstractModel.js

@@ -46,7 +46,8 @@ export class AbstractModel {
         let records = await this._destroy(criteria);
         return records.map(record => dataAccessor.process(record));
     }
-    async count(criteria) {
+    async count(criteria, dataAccessor) {
+        criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
         return this._count(criteria);
     }
 }

package/lib/v4/model/ModelHandler.js

@@ -3,12 +3,10 @@ export class ModelHandler {
     models = new Map();
     add(modelName, modelInstance) {
         const modelname = modelName.toLowerCase();
-        if (this.models.has(modelname)) {
-            throw new Error(`Model "${modelname}" is already registered.`);
-        }
         this.models.set(modelname, modelInstance);
         Adminizer.log.debug(`Model with name [${modelname}] was registered`);
     }
+    // TODO: 'hot reload' need add method for delete model
     /** Improved model getter, so you can write both model.get("UserAP") and model.get("userap") */
     get model() {
         return {

package/lib/v4/model/adapter/sequelize.d.ts

@@ -4,6 +4,14 @@ export declare function mapSequelizeToWaterline(model: ModelStatic<any>): Record
 export declare class SequelizeModel<T> extends AbstractModel<T> {
     private model;
     constructor(modelName: string, model: ModelStatic<any>);
+    _convertCriteriaToSequelize(criteria: any): any;
+    _convertWaterlineCriteriaToSequelizeOptions(criteria: any): {
+        where?: any;
+        limit?: number;
+        offset?: number;
+        order?: any[];
+    };
+    _assignAssociations(instance: any, assocData: Record<string, any>): Promise<void>;
     protected _create(data: Record<string, any>): Promise<T>;
     protected _findOne(criteria: Partial<T>): Promise<T | null>;
     protected _find(criteria?: Partial<T>, options?: FindOptions): Promise<T[]>;