adminizer 4.7.0-build.222 → 5.0.0-build.0

package/lib/catalog/Navigation.js

@@ -1,492 +0,0 @@
-import { AbstractCatalog, AbstractGroup, AbstractItem } from "./AbstractCatalog.js";
-import { v4 as uuid } from "uuid";
-import { Adminizer } from "../Adminizer.js";
-export class StorageService {
-    storageMap = new Map();
-    id;
-    model;
-    adminizer;
-    ready;
-    constructor(adminizer, id, model) {
-        this.adminizer = adminizer;
-        this.id = id;
-        this.model = model.toLowerCase();
-        this.ready = this.initModel();
-    }
-    navigationModel() {
-        return this.adminizer.modelHandler.internal("navigation").get(this.model);
-    }
-    async initModel() {
-        const navigation = await this.navigationModel().findOne({ where: { 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: [] };
-            await this.navigationModel().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: itemData.parentId === 0 ? null : 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 {
-            await this.navigationModel().update({ where: { 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 (parentId === 0)
-                parentId = null;
-            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 {
-    storages = [];
-    constructor() {
-    }
-    add(storage) {
-        this.storages.push(storage);
-    }
-    get(id) {
-        return this.storages.find(storage => storage.getId() === id);
-    }
-    getAll() {
-        return this.storages;
-    }
-    /** Resolves when all sections have finished loading from the database */
-    async ready() {
-        await Promise.all(this.storages.map(s => s.ready));
-    }
-}
-export class Navigation extends AbstractCatalog {
-    name = 'Navigation';
-    slug = 'navigation';
-    icon = "box";
-    actionHandlers = [];
-    idList = [];
-    storageServices;
-    constructor(adminizer, config) {
-        let items = [];
-        const storageServices = new StorageServices();
-        for (const configElement of config.items) {
-            items.push(new NavigationItem(adminizer, configElement.title, configElement.model, config.model, configElement.urlPath, storageServices));
-        }
-        items.push(new NavigationGroup(adminizer, config.groupField, storageServices));
-        items.push(new LinkItem(adminizer, storageServices));
-        super(adminizer, items);
-        this.storageServices = storageServices;
-        adminizer.storageServices = storageServices;
-        for (const section of config.sections) {
-            this.storageServices.add(new StorageService(adminizer, section, config.model));
-        }
-        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, storageServices) {
-        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;
-        this.storageServices = storageServices;
-    }
-    contentModel() {
-        return this.adminizer.modelHandler.internal("navigation").get(this.model);
-    }
-    async create(data, catalogId) {
-        let storage = this.storageServices.get(catalogId);
-        let storageData = null;
-        if (data._method === 'select') {
-            let record = await this.contentModel().findOne({ where: { id: data.record } });
-            storageData = await this.dataPreparation({
-                record: record,
-                parentId: data.parentId,
-                targetBlank: data.targetBlank,
-                visible: data.visible
-            }, catalogId);
-        }
-        else {
-            storageData = await this.dataPreparation(data, catalogId);
-        }
-        return await storage.setElement(data.id, storageData);
-    }
-    async dataPreparation(data, catalogId, sortOrder) {
-        let storage = this.storageServices.get(catalogId);
-        let urlPath = eval('`' + this.urlPath + '`');
-        let parentId = data.parentId ? data.parentId : null; // changed from 0 to null
-        if (parentId === 0)
-            parentId = null;
-        return {
-            id: uuid(),
-            modelId: data.record.id,
-            targetBlank: data.targetBlank ?? data.record.targetBlank,
-            visible: data.visible ?? data.record.visible,
-            isNavigation: true,
-            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 = this.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;
-                item.visible = data.record.visible;
-            }
-            response.push(await storage.setElement(item.id, item));
-        }
-        return response[0];
-    }
-    async update(itemId, data, catalogId) {
-        let storage = this.storageServices.get(catalogId);
-        return await storage.setElement(itemId, data);
-    }
-    async deleteItem(itemId, catalogId) {
-        let storage = this.storageServices.get(catalogId);
-        return await storage.removeElementById(itemId);
-    }
-    async find(itemId, catalogId) {
-        let storage = this.storageServices.get(catalogId);
-        return await storage.findElementById(itemId);
-    }
-    /**
-     * @deprecated reason: transition to Inertia
-    * // TODO: need passing custom React module
-    */
-    async getAddTemplate(req) {
-        let type = 'model.link';
-        let itemsDB = await this.contentModel().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'),
-                    visible: req.i18n.__('Visible')
-                }
-            }
-        };
-    }
-    async getChilds(parentId, catalogId) {
-        let storage = this.storageServices.get(catalogId);
-        return await storage.findElementsByParentId(parentId, this.type);
-    }
-    async getEditTemplate(id, catalogId, req, modelId) {
-        return Promise.resolve({
-            type: 'model.link',
-            data: {
-                item: await this.find(id, catalogId)
-            }
-        });
-    }
-    async search(s, catalogId) {
-        let storage = this.storageServices.get(catalogId);
-        return await storage.search(s, this.type);
-    }
-}
-class NavigationGroup extends AbstractGroup {
-    allowedRoot = true;
-    name = "Group";
-    groupField;
-    adminizer;
-    constructor(adminizer, groupField, storageServices) {
-        super();
-        this.groupField = groupField;
-        this.adminizer = adminizer;
-        this.storageServices = storageServices;
-    }
-    async create(data, catalogId) {
-        let storage = this.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 = this.storageServices.get(catalogId);
-        let parentId = data.parentId ? data.parentId : null; // changed from 0 to null
-        if (parentId === 0)
-            parentId = null;
-        return {
-            id: uuid(),
-            name: data.name,
-            targetBlank: data.targetBlank,
-            visible: data.visible,
-            isNavigation: true,
-            parentId: parentId,
-            sortOrder: sortOrder ?? (await storage.findElementsByParentId(parentId, null)).length,
-            icon: this.icon,
-            type: this.type
-        };
-    }
-    async deleteItem(itemId, catalogId) {
-        let storage = this.storageServices.get(catalogId);
-        return await storage.removeElementById(itemId);
-    }
-    async find(itemId, catalogId) {
-        let storage = this.storageServices.get(catalogId);
-        return await storage.findElementById(itemId);
-    }
-    async update(itemId, data, catalogId) {
-        let storage = this.storageServices.get(catalogId);
-        return await storage.setElement(itemId, data);
-    }
-    async updateModelItems(modelId, data, catalogId) {
-        let storage = this.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,
-                    label: field.label,
-                    required: field.required
-                };
-            });
-        }
-        return Promise.resolve({
-            type: type,
-            data: {
-                items: resItems,
-                labels: {
-                    openInNewWindow: req.i18n.__('Open in a new window'),
-                    visible: req.i18n.__('Visible'),
-                    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,
-                    label: field.label,
-                    required: field.required
-                };
-            });
-        }
-        return Promise.resolve({
-            type: type,
-            data: {
-                items: resItems,
-                item: item,
-                labels: {
-                    openInNewWindow: req.i18n.__('Open in a new window'),
-                    visible: req.i18n.__('Visible'),
-                    title: req.i18n.__('Title'),
-                    save: req.i18n.__('Save')
-                }
-            }
-        });
-    }
-    async getChilds(parentId, catalogId) {
-        let storage = this.storageServices.get(catalogId);
-        return await storage.findElementsByParentId(parentId, this.type);
-    }
-    async search(s, catalogId) {
-        let storage = this.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, storageServices) {
-        super(adminizer, [], storageServices);
-    }
-    getAddTemplate(req) {
-        let type = 'navigation.link';
-        let resItems = [
-            {
-                label: req.i18n.__('Link'),
-                name: "link",
-                required: true
-            }
-        ];
-        return Promise.resolve({
-            type: type,
-            data: {
-                items: resItems,
-                labels: {
-                    title: req.i18n.__('Title'),
-                    openInNewWindow: req.i18n.__('Open in a new window'),
-                    visible: req.i18n.__('Visible'),
-                    save: req.i18n.__('Save')
-                }
-            }
-        });
-    }
-    async getEditTemplate(id, catalogId, req) {
-        let item = await this.find(id, catalogId);
-        let type = 'navigation.group';
-        let resItems = [
-            {
-                label: req.i18n.__('Link'),
-                name: 'link',
-                required: true
-            }
-        ];
-        return Promise.resolve({
-            type: type,
-            data: {
-                items: resItems,
-                item: item,
-                labels: {
-                    openInNewWindow: req.i18n.__('Open in a new window'),
-                    visible: req.i18n.__('Visible'),
-                    title: req.i18n.__('Title'),
-                    save: req.i18n.__('Save')
-                }
-            }
-        });
-    }
-}

package/lib/controls/AbstractControls.d.ts

@@ -1,30 +0,0 @@
-import { Adminizer } from "../Adminizer";
-export type ControlType = 'wysiwyg' | 'jsonEditor' | 'geoJson' | 'markdown' | 'table' | 'codeEditor';
-export interface Path {
-    jsPath: {
-        dev: string;
-        production: string;
-    };
-    cssPath: string;
-}
-export type Config = Record<string, string | string[] | object | number | boolean>;
-/**
- * AbstractControls
- */
-export declare abstract class AbstractControls {
-    abstract readonly name: string;
-    abstract readonly type: ControlType;
-    abstract readonly path: Path;
-    abstract readonly config: Config;
-    readonly routPrefix: string;
-    /**
-     * @requires
-     * @param adminizer
-     * @protected
-     */
-    protected constructor(adminizer: Adminizer);
-    abstract getConfig(): Config | undefined;
-    abstract getJsPath(): string | undefined;
-    abstract getCssPath(): string | undefined;
-    abstract getName(): string;
-}

package/lib/controls/AbstractControls.js

@@ -1,14 +0,0 @@
-/**
- * AbstractControls
- */
-export class AbstractControls {
-    routPrefix;
-    /**
-     * @requires
-     * @param adminizer
-     * @protected
-     */
-    constructor(adminizer) {
-        this.routPrefix = adminizer.config.routePrefix;
-    }
-}

package/lib/media-manager/DefaultMediaManager.d.ts

@@ -1,20 +0,0 @@
-import { AbstractMediaManager, MediaManagerItem, File, MediaManagerWidgetData, MediaManagerWidgetClientItem, SortCriteria } from "./AbstractMediaManager";
-import { Adminizer } from "../Adminizer";
-export declare class DefaultMediaManager extends AbstractMediaManager {
-    readonly itemTypes: File<MediaManagerItem>[];
-    model: string;
-    modelAssoc: string;
-    id: string;
-    protected readonly adminizer: Adminizer;
-    constructor(adminizer: Adminizer, id: string, urlPathPrefix: string, fileStoragePath: string);
-    private mediaModel;
-    private associationModel;
-    getAll(limit: number, skip: number, sort: SortCriteria, group: string): Promise<{
-        data: MediaManagerItem[];
-        next: boolean;
-    }>;
-    searchAll(s: string, group: string): Promise<MediaManagerItem[]>;
-    setRelations(data: MediaManagerWidgetData[], model: string, modelId: string | number, //Updated
-    widgetName: string): Promise<void>;
-    getRelations(model: string, widgetName: string, modelId: string | number): Promise<MediaManagerWidgetClientItem[]>;
-}

package/lib/media-manager/DefaultMediaManager.js

@@ -1,127 +0,0 @@
-import { AbstractMediaManager, } from "./AbstractMediaManager.js";
-import { populateVariants } from "./helpers/MediaManagerHelper.js";
-import { ApplicationItem, ImageItem, TextItem, VideoItem } from "./Items.js";
-export class DefaultMediaManager extends AbstractMediaManager {
-    itemTypes = [];
-    model = "mediamanagerap";
-    modelAssoc = "mediamanagerassociationsap";
-    id;
-    adminizer;
-    constructor(adminizer, id, urlPathPrefix, fileStoragePath) {
-        super(adminizer);
-        this.id = id;
-        this.urlPathPrefix = urlPathPrefix;
-        this.fileStoragePath = fileStoragePath;
-        this.itemTypes.push(new ImageItem(adminizer, urlPathPrefix, fileStoragePath));
-        this.itemTypes.push(new TextItem(adminizer, urlPathPrefix, fileStoragePath));
-        this.itemTypes.push(new ApplicationItem(adminizer, urlPathPrefix, fileStoragePath));
-        this.itemTypes.push(new VideoItem(adminizer, urlPathPrefix, fileStoragePath));
-        this.adminizer = adminizer;
-    }
-    mediaModel() {
-        return this.adminizer.modelHandler.internal("media-manager").get(this.model);
-    }
-    associationModel() {
-        return this.adminizer.modelHandler.internal("media-manager").get(this.modelAssoc);
-    }
-    async getAll(limit, skip, sort, group) {
-        let data = await this.mediaModel().find({
-            where: { parent: null, group: group },
-            limit: limit,
-            skip: skip,
-            sort: sort,
-            populate: {
-                variants: { sort: sort },
-                meta: true
-            }
-        });
-        let next = await this.mediaModel().find({
-            where: { parent: null, group: group },
-            limit: limit,
-            skip: skip === 0 ? limit : skip + limit,
-            sort: sort,
-        });
-        for (let elem of data) {
-            elem.variants = await populateVariants(this.adminizer, elem.variants, this.model);
-        }
-        return {
-            data: data,
-            next: !!next.length,
-        };
-    }
-    async searchAll(s, group) {
-        let data = await this.mediaModel().find({
-            where: { filename: { contains: s }, parent: null, group: group },
-            sort: "createdAt DESC",
-            // This limitation is made strictly, if your code solves this please make a PR
-            limit: 1000,
-            populate: {
-                variants: { sort: "createdAt DESC" },
-                meta: true
-            }
-        });
-        for (let elem of data) {
-            elem.variants = await populateVariants(this.adminizer, elem.variants, this.model);
-        }
-        return data;
-    }
-    async setRelations(data, model, modelId, //Updated
-    widgetName) {
-        if (modelId == null) {
-            throw new Error("modelId must be a string or number");
-        }
-        const modelIdStr = String(modelId); //Normalize to string
-        const associationModel = this.associationModel();
-        let modelAssociations = await associationModel.find({
-            where: {
-                modelId: modelIdStr,
-                model: model.toLowerCase(),
-                widgetName: widgetName,
-            },
-        });
-        for (const modelAssociation of modelAssociations) {
-            const q = {};
-            const pk = this.adminizer.modelHandler.model.get(this.modelAssoc).primaryKey;
-            q[pk] = modelAssociation.id;
-            await associationModel.destroy({ where: q });
-        }
-        const fieldName = this.adminizer.ormAdapters[0].ormType === 'sequelize' ? 'fileId' : 'file';
-        for (const [key, widgetItem] of data.entries()) {
-            await associationModel.create({
-                mediaManagerId: this.id,
-                model: model.toLowerCase(),
-                modelId: modelIdStr, //Save as a string
-                [fieldName]: widgetItem.id,
-                widgetName: widgetName,
-                sortOrder: key + 1,
-            });
-        }
-    }
-    async getRelations(model, widgetName, modelId) {
-        if (modelId == null) {
-            throw new Error("modelId must be a string or number");
-        }
-        const modelIdStr = String(modelId); //Normalize to string
-        let widgetItems = [];
-        const fieldName = this.adminizer.ormAdapters[0].ormType === 'sequelize' ? 'fileRef' : 'file';
-        let files = await this.associationModel().find({
-            where: {
-                model: model.toLowerCase(),
-                widgetName: widgetName,
-                modelId: modelIdStr, //Search by string
-            },
-            sort: "sortOrder ASC",
-            populate: { [fieldName]: true }
-        });
-        for (const file of files) {
-            widgetItems.push({
-                id: file[fieldName].id,
-                mimeType: file[fieldName].mimeType,
-                filename: file[fieldName].filename,
-                url: file[fieldName].url,
-                variants: []
-            });
-        }
-        return widgetItems;
-    }
-}