adminizer 4.1.0-commit.ad1476a → 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

@@ -98,7 +98,6 @@ export class NodeTable {
                             columnQuery = { [fieldsArray[parseInt(columnName)]]: { contains: searchStr } };
                             break;
                         default:
-                            // Пропускаем json, ref и ассоциации
                             break;
                     }
                 }
@@ -132,10 +131,9 @@ 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);
-            console.log(data, "data");
             const output = {
                 draw: this.request.draw !== "" ? this.request.draw : 0,
                 recordsTotal: totalRecords,
@@ -162,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]);
                 }
@@ -171,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") {
@@ -181,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]);
@@ -201,7 +202,6 @@ export class NodeTable {
             });
             out.push(row);
         });
-        console.log(out);
         return out;
     }
 }

package/lib/v4/helper/jwt.d.ts

@@ -0,0 +1,10 @@
+export declare function signUser(user: JwtPayload, JWT_SECRET: string): string;
+interface JwtPayload {
+    id: number;
+    login: string;
+    isAdministrator?: boolean;
+    iat?: number;
+    exp?: number;
+}
+export declare function verifyUser(token: string, JWT_SECRET: string): JwtPayload | null;
+export {};

package/lib/v4/helper/jwt.js

@@ -0,0 +1,18 @@
+import jwt from 'jsonwebtoken';
+export function signUser(user, JWT_SECRET) {
+    return jwt.sign(user, JWT_SECRET, {
+        expiresIn: '15d',
+    });
+}
+export function verifyUser(token, JWT_SECRET) {
+    try {
+        const decoded = jwt.verify(token, JWT_SECRET);
+        if (typeof decoded === 'object' && decoded !== null && 'id' in decoded && 'login' in decoded) {
+            return decoded;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}

package/lib/{inertia → v4/inertia}/inertiaAdapter.js

@@ -21,7 +21,6 @@ const inertiaExpressAdapter = function ({ version, html, flashMessages, enableRe
             if (!['GET', 'HEAD', 'OPTIONS'].includes(req.method)) {
                 const csrfCookie = req.cookies['XSRF-TOKEN'];
                 const csrfHeader = req.headers[csrf.headerName || 'x-xsrf-token'];
-                // console.log('headers:', req.headers['x-xsrf-token']);
                 if (!csrfCookie || !csrfHeader || csrfCookie !== csrfHeader) {
                     res.status(403).send({ message: 'Invalid CSRF token' });
                     return;

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

@@ -17,13 +17,11 @@ export class AbstractModel {
     async findOne(criteria, dataAccessor) {
         criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
         let record = await this._findOne(criteria);
-        console.log(record, "record");
         return record ? dataAccessor.process(record) : null;
     }
     async find(criteria, dataAccessor) {
         criteria = await dataAccessor.sanitizeUserRelationAccess(criteria);
         let records = await this._find(criteria);
-        console.log(records, "records");
         return records.map(record => dataAccessor.process(record));
     }
     async updateOne(criteria, data, dataAccessor) {
@@ -48,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,13 +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`);
-        console.log(`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 {