adminizer 4.7.0-build.224 → 5.0.0-build.1

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

@@ -1,50 +0,0 @@
-import { File, MediaFileType, MediaManagerItem, SortCriteria, UploaderFile } from "./AbstractMediaManager";
-import sharp from "sharp";
-import { Adminizer } from "../Adminizer";
-export declare class ImageItem extends File<MediaManagerItem> {
-    type: MediaFileType;
-    model: string;
-    metaModel: string;
-    modelAssoc: string;
-    imageSizes: any;
-    protected readonly adminizer: Adminizer;
-    constructor(adminizer: Adminizer, urlPathPrefix: string, fileStoragePath: string);
-    protected mediaModel(): import("../..").InternalModelRepository<MediaManagerItem>;
-    protected metaRepository(): import("../..").InternalModelRepository<any>;
-    protected associationModel(): import("../..").InternalModelRepository<any>;
-    getItems(limit: number, skip: number, sort: SortCriteria, group: string): Promise<{
-        data: MediaManagerItem[];
-        next: boolean;
-    }>;
-    search(s: string, group: string): Promise<MediaManagerItem[]>;
-    upload(file: UploaderFile, filename: string, origFileName: string, group: string): Promise<MediaManagerItem[]>;
-    getVariants(id: string): Promise<MediaManagerItem[]>;
-    protected createVariants(file: UploaderFile, parent: MediaManagerItem, filename: string, group: string): Promise<void>;
-    getOrigin(id: string): Promise<string>;
-    getFile(id: number | string): Promise<MediaManagerItem>;
-    protected createMeta(id: string): Promise<void>;
-    protected addFileMeta(file: string, id: string): Promise<void>;
-    getMeta(id: string): Promise<{
-        key: string;
-        value: string;
-    }[]>;
-    setMeta(id: string, data: {
-        [p: string]: string;
-    }): Promise<void>;
-    protected resizeImage(input: string, output: string, width: number, height: number): Promise<sharp.OutputInfo>;
-    uploadVariant(parent: MediaManagerItem, file: UploaderFile, filename: string, group: string, localeId: string): Promise<MediaManagerItem>;
-    delete(id: string): Promise<boolean>;
-}
-export declare class TextItem extends ImageItem {
-    type: MediaFileType;
-    upload(file: UploaderFile, filename: string, origFileName: string, group: string): Promise<MediaManagerItem[]>;
-    getvariants(): Promise<MediaManagerItem[]>;
-    uploadVariant(parent: MediaManagerItem, file: UploaderFile, filename: string, group: string, localeId: string): Promise<MediaManagerItem>;
-    getVariants(id: string): Promise<MediaManagerItem[]>;
-}
-export declare class ApplicationItem extends TextItem {
-    type: MediaFileType;
-}
-export declare class VideoItem extends TextItem {
-    type: MediaFileType;
-}

package/lib/media-manager/Items.js

@@ -1,296 +0,0 @@
-import { File } from "./AbstractMediaManager.js";
-import { populateVariants, randomFileName } from "./helpers/MediaManagerHelper.js";
-import sizeOf from "image-size";
-import sharp from "sharp";
-import * as fs from 'fs';
-import * as path from 'path';
-import * as process from "node:process";
-export class ImageItem extends File {
-    type = "image";
-    model = "mediamanagerap";
-    metaModel = "mediamanagermetaap";
-    modelAssoc = "mediamanagerassociationsap";
-    imageSizes;
-    adminizer;
-    constructor(adminizer, urlPathPrefix, fileStoragePath) {
-        super(urlPathPrefix, fileStoragePath);
-        this.imageSizes = adminizer.config.mediamanager.imageSizes || {};
-        this.adminizer = adminizer;
-    }
-    mediaModel() {
-        return this.adminizer.modelHandler.internal("media-manager").get(this.model);
-    }
-    metaRepository() {
-        return this.adminizer.modelHandler.internal("media-manager").get(this.metaModel);
-    }
-    associationModel() {
-        return this.adminizer.modelHandler.internal("media-manager").get(this.modelAssoc);
-    }
-    async getItems(limit, skip, sort, group) {
-        let data = await this.mediaModel().find({
-            where: { parent: null, mimeType: { contains: this.type }, group: group },
-            limit: limit,
-            skip: skip,
-            sort: sort,
-            populate: {
-                variants: { sort: sort },
-                meta: true
-            }
-        });
-        let next = await this.mediaModel().find({
-            where: { parent: null, mimeType: { contains: this.type }, 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 search(s, group) {
-        let data = await this.mediaModel().find({
-            where: { filename: { contains: s }, mimeType: { contains: this.type }, parent: null, group: group },
-            sort: "createdAt DESC",
-            populate: {
-                variants: { sort: "createdAt DESC" }
-            }
-        });
-        for (let elem of data) {
-            elem.variants = await populateVariants(this.adminizer, elem.variants, this.model);
-        }
-        return data;
-    }
-    async upload(file, filename, origFileName, group) {
-        let parent = await this.mediaModel().create({
-            parent: null,
-            mimeType: file.mimetype,
-            size: file.size,
-            path: `${this.fileStoragePath}/${this.urlPathPrefix}/${filename}`,
-            group: group,
-            tag: "origin",
-            filename: origFileName,
-            url: `/${this.urlPathPrefix}/${filename}`,
-        });
-        await this.createMeta(parent.id);
-        await this.addFileMeta(file.path, parent.id);
-        // create file variants
-        if (Object.keys(this.imageSizes).length && file.mimetype !== 'image/svg+xml') {
-            await this.createVariants(file, parent, filename, group);
-        }
-        const item = await this.mediaModel().findOne({ where: { id: parent.id } });
-        item.variants = await populateVariants(this.adminizer, item.variants, this.model);
-        return [item];
-    }
-    async getVariants(id) {
-        let items = ((await this.mediaModel().find({
-            where: { id: id },
-            populate: {
-                variants: { sort: "createdAt DESC" }
-            }
-        }))[0]).variants;
-        return (await populateVariants(this.adminizer, items, this.model));
-    }
-    async createVariants(file, parent, filename, group) {
-        for (const sizeKey of Object.keys(this.imageSizes)) {
-            let sizeName = randomFileName(filename, sizeKey, false);
-            let { width, height } = this.imageSizes[sizeKey];
-            const buffer = fs.readFileSync(file.path);
-            const image = sizeOf(buffer);
-            if (image.width < width || image.height < height)
-                continue;
-            const output = `${this.fileStoragePath}/${this.urlPathPrefix}/${sizeName}`;
-            let newFile = await this.resizeImage(file.path, output, width, height);
-            let newSize = await this.mediaModel().create({
-                parent: parent.id,
-                mimeType: parent.mimeType,
-                size: newFile.size,
-                filename: parent.filename,
-                group: group,
-                path: output,
-                tag: `saze:${sizeKey}`,
-                url: `/${this.urlPathPrefix}/${sizeName}`,
-            });
-            await this.addFileMeta(output, newSize.id);
-        }
-    }
-    async getOrigin(id) {
-        return (await this.mediaModel().findOne({ where: { id: id } })).path;
-    }
-    async getFile(id) {
-        let item = await this.mediaModel().findOne({ where: { id: String(id) } });
-        item.variants = await populateVariants(this.adminizer, item.variants, this.model);
-        return item;
-    }
-    async createMeta(id) {
-        //create empty meta
-        let metaData = {
-            author: "",
-            description: "",
-            title: "",
-        };
-        for (const key of Object.keys(metaData)) {
-            await this.metaRepository().create({
-                key: key,
-                value: metaData[key],
-                parent: id,
-                isPublic: true
-            });
-        }
-    }
-    async addFileMeta(file, id) {
-        const metaBuffer = fs.readFileSync(file);
-        await this.metaRepository().create({
-            key: 'imageSizes',
-            value: sizeOf(metaBuffer),
-            parent: id,
-            isPublic: false
-        });
-    }
-    // TODO  {where: {isPublic: true}, sort: "id ASC"} ???
-    async getMeta(id) {
-        return ((await this.mediaModel().find({
-            where: { id: id },
-            populate: {
-                meta: { where: { isPublic: true } }
-            }
-        }))[0]).meta;
-    }
-    async setMeta(id, data) {
-        for (const key of Object.keys(data)) {
-            await this.metaRepository().update({ where: { parent: id, key: key } }, { value: data[key] });
-        }
-    }
-    async resizeImage(input, output, width, height) {
-        // Get the directory from the output path
-        const outputDir = `${process.cwd()}/${path.dirname(output)}`;
-        // Check if the directory exists, and create it if it doesn't
-        if (!fs.existsSync(outputDir)) {
-            fs.mkdirSync(outputDir, { recursive: true });
-        }
-        // Resize the image and save it to the output path
-        return await sharp(input)
-            .resize({ width: width, height: height })
-            .toFile(output);
-    }
-    async uploadVariant(parent, file, filename, group, localeId) {
-        const variantBuffer = fs.readFileSync(file.path);
-        const { width, height } = sizeOf(variantBuffer);
-        let item = await this.mediaModel().create({
-            parent: parent.id,
-            mimeType: file.mimetype,
-            size: file.size,
-            path: file.path,
-            group: group,
-            tag: localeId ? `loc:${localeId}` : `size:${width}x${height}`,
-            filename: parent.filename,
-            url: `/${this.urlPathPrefix}/${filename}`,
-        });
-        await this.addFileMeta(file.path, item.id);
-        return (await this.mediaModel().findOne({ where: { id: item.id } }));
-    }
-    async delete(id) {
-        const fieldName = this.adminizer.ormAdapters[0].ormType === 'sequelize' ? 'fileId' : 'file';
-        const assoc = await this.associationModel().find({ where: { [fieldName]: id } });
-        if (assoc.length) {
-            return Promise.resolve(false);
-        }
-        const criteria = { where: { id: id } };
-        let record = await this.mediaModel().findOne(criteria);
-        await beforeDestroy(this.adminizer, criteria);
-        await this.mediaModel().destroy({ where: { id: id } });
-        await deleteFile(record.path);
-        // Delete all variants
-        if (record.variants.length) {
-            for (const variant of record.variants) {
-                await deleteFile(variant.path);
-            }
-        }
-        return Promise.resolve(true);
-    }
-}
-/*
- * Text item
- */
-export class TextItem extends ImageItem {
-    type = "text";
-    async upload(file, filename, origFileName, group) {
-        let parent = await this.mediaModel().create({
-            parent: null,
-            mimeType: file.mimetype,
-            size: file.size,
-            path: `${this.fileStoragePath}/${filename}`,
-            group: group,
-            filename: origFileName,
-            tag: "origin",
-            url: `/${this.urlPathPrefix}/${filename}`,
-        });
-        await this.createMeta(parent.id);
-        const item = await this.mediaModel().findOne({ where: { id: parent.id } });
-        item.variants = await populateVariants(this.adminizer, item.variants, this.model);
-        return [item];
-    }
-    getvariants() {
-        return Promise.resolve([]);
-    }
-    async uploadVariant(parent, file, filename, group, localeId) {
-        let variants = parent.variants.filter(e => /^loc:/.test(e.tag) === false);
-        let item = await this.mediaModel().create({
-            parent: parent.id,
-            mimeType: file.mimetype,
-            size: file.size,
-            path: file.path,
-            group: group,
-            tag: localeId ? `loc:${localeId}` : `ver: ${variants.length + 1}`,
-            filename: parent.filename,
-            url: `/${this.urlPathPrefix}/${filename}`,
-        });
-        return (await this.mediaModel().findOne({ where: { id: item.id } }));
-    }
-    async getVariants(id) {
-        let items = ((await this.mediaModel().find({
-            where: { id: id },
-            populate: {
-                variants: { sort: "createdAt DESC" }
-            }
-        }))[0]).variants;
-        return (await populateVariants(this.adminizer, items, this.model));
-    }
-}
-export class ApplicationItem extends TextItem {
-    type = "application";
-}
-export class VideoItem extends TextItem {
-    type = "video";
-}
-async function beforeDestroy(adminizer, criteria) {
-    const mediaModel = adminizer.modelHandler.internal("media-manager").get("MediaManagerAP");
-    const metaModel = adminizer.modelHandler.internal("media-manager").get("MediaManagerMetaAP");
-    let parent = (await mediaModel.find(criteria))[0];
-    let meta = parent.meta;
-    for (const metaElement of meta) {
-        await metaModel.destroy({ where: { id: metaElement.id } });
-    }
-    let variants = (await mediaModel.find(criteria))[0].variants;
-    for (const child of variants) {
-        await mediaModel.destroy({ where: { id: child.id } });
-    }
-}
-async function deleteFile(file) {
-    try {
-        await fs.promises.access(file);
-        await fs.promises.unlink(file);
-    }
-    catch (err) {
-        if (err.code === 'ENOENT') {
-        }
-        else if (err.code === 'EPERM') {
-        }
-        else {
-            console.error(`An error occurred: ${err}`);
-        }
-    }
-}

package/models/FilterAP.js

@@ -1,68 +0,0 @@
-/**
- * Filter model schema
- */
-export default {
-    id: {
-        type: "string",
-        primaryKey: true
-        // UUID will be generated before create
-    },
-    name: {
-        type: "string",
-        required: true
-    },
-    description: {
-        type: "string"
-    },
-    modelName: {
-        type: "string",
-        required: true
-    },
-    conditions: {
-        type: "json"
-    },
-    sortField: {
-        type: "string"
-    },
-    sortDirection: {
-        type: "string"
-        // 'ASC' or 'DESC'
-    },
-    visibility: {
-        type: "string"
-        // 'private' | 'public' | 'groups' | 'system'
-    },
-    ownerId: {
-        type: "number"
-    },
-    groupIds: {
-        type: "json"
-    },
-    apiEnabled: {
-        type: "boolean"
-    },
-    apiKey: {
-        type: "string"
-    },
-    icon: {
-        type: "string"
-    },
-    color: {
-        type: "string"
-    },
-    version: {
-        type: "number"
-    },
-    columns: {
-        collection: "FilterColumnAP",
-        via: "filter"
-    },
-    createdAt: {
-        type: 'datetime',
-        autoCreatedAt: true
-    },
-    updatedAt: {
-        type: 'datetime',
-        autoUpdatedAt: true
-    }
-};

package/models/FilterColumnAP.d.ts

@@ -1,32 +0,0 @@
-import { FilterAP } from "./FilterAP";
-/**
- * FilterColumnAP model schema
- * Represents column configuration for a filter
- */
-declare const _default: {
-    id: {
-        type: string;
-        autoIncrement: boolean;
-        primaryKey: boolean;
-    };
-    filter: {
-        model: string;
-    };
-    fieldName: {
-        type: string;
-        required: boolean;
-    };
-    order: {
-        type: string;
-    };
-};
-export default _default;
-/**
- * FilterColumnAP interface for TypeScript
- */
-export interface FilterColumnAP {
-    id?: number;
-    filter: string | FilterAP;
-    fieldName: string;
-    order: number;
-}

package/models/FilterColumnAP.js

@@ -1,21 +0,0 @@
-/**
- * FilterColumnAP model schema
- * Represents column configuration for a filter
- */
-export default {
-    id: {
-        type: "number",
-        autoIncrement: true,
-        primaryKey: true
-    },
-    filter: {
-        model: 'FilterAP'
-    },
-    fieldName: {
-        type: "string",
-        required: true
-    },
-    order: {
-        type: "number"
-    }
-};

package/models/GroupAP.d.ts

@@ -1,31 +0,0 @@
-import { UserAP } from "./UserAP";
-declare const _default: {
-    id: {
-        type: string;
-        autoIncrement: boolean;
-        primaryKey: boolean;
-    };
-    name: {
-        type: string;
-        required: boolean;
-        unique: boolean;
-    };
-    description: {
-        type: string;
-    };
-    tokens: {
-        type: string;
-    };
-    users: {
-        collection: string;
-        via: string;
-    };
-};
-export default _default;
-export interface GroupAP {
-    id?: number;
-    name: string;
-    description?: string;
-    tokens?: string[];
-    users?: UserAP[];
-}

package/models/GroupAP.js

@@ -1,22 +0,0 @@
-export default {
-    id: {
-        type: "number",
-        autoIncrement: true,
-        primaryKey: true
-    },
-    name: {
-        type: "string",
-        required: true,
-        unique: true
-    },
-    description: {
-        type: "string"
-    },
-    tokens: {
-        type: "json"
-    },
-    users: {
-        collection: "UserAP",
-        via: "groups"
-    }
-};

package/models/HistoryActionsAP.d.ts

@@ -1,56 +0,0 @@
-import { UserAP } from "./UserAP";
-declare const _default: {
-    id: {
-        type: string;
-        autoIncrement: boolean;
-        primaryKey: boolean;
-    };
-    modelId: {
-        type: string;
-        required: boolean;
-    };
-    modelName: {
-        type: string;
-        required: boolean;
-    };
-    action: {
-        type: string;
-    };
-    data: {
-        type: string;
-    };
-    diff: {
-        type: string;
-    };
-    user: {
-        model: string;
-    };
-    isCurrent: {
-        type: string;
-    };
-    createdAt: {
-        type: string;
-        autoCreatedAt: boolean;
-    };
-    updatedAt: {
-        type: string;
-        autoUpdatedAt: boolean;
-    };
-    preview: {
-        type: string;
-    };
-};
-export default _default;
-export interface HistoryActionsAP {
-    id?: number;
-    modelId: number | string;
-    modelName: string;
-    action: string;
-    data: any;
-    diff: any;
-    user: UserAP;
-    isCurrent: boolean;
-    createdAt?: number;
-    updatedAt?: number;
-    preview: boolean;
-}

package/models/HistoryActionsAP.js

@@ -1,42 +0,0 @@
-export default {
-    id: {
-        type: "number",
-        autoIncrement: true,
-        primaryKey: true
-    },
-    modelId: {
-        type: "string",
-        required: true
-    },
-    modelName: {
-        type: "string",
-        required: true
-    },
-    action: {
-        type: "string",
-    },
-    // here stored raw data foreach history-action better to store as incremental binary data
-    data: {
-        type: "json",
-    },
-    diff: {
-        type: "json",
-    },
-    user: {
-        model: 'UserAP'
-    },
-    isCurrent: {
-        type: 'boolean',
-    },
-    createdAt: {
-        type: 'datetime',
-        autoCreatedAt: true
-    },
-    updatedAt: {
-        type: 'datetime',
-        autoUpdatedAt: true
-    },
-    preview: {
-        type: 'boolean'
-    }
-};

package/models/NavigationAP.d.ts

@@ -1,22 +0,0 @@
-declare const _default: {
-    id: {
-        type: string;
-        autoIncrement: boolean;
-        primaryKey: boolean;
-    };
-    label: {
-        type: string;
-        required: boolean;
-        unique: boolean;
-    };
-    tree: {
-        type: string;
-        required: boolean;
-    };
-};
-export default _default;
-export interface NavigationAP {
-    id?: string;
-    label: string;
-    tree: Record<string, unknown>;
-}

package/models/NavigationAP.js

@@ -1,16 +0,0 @@
-export default {
-    id: {
-        type: "number",
-        autoIncrement: true,
-        primaryKey: true
-    },
-    label: {
-        type: "string",
-        required: true,
-        unique: true
-    },
-    tree: {
-        type: "json",
-        required: true
-    }
-};