adminizer 4.1.0-build.2 → 4.1.0-build.21

package/controllers/processInstallStep.js

@@ -1,132 +0,0 @@
-import { InstallStepper } from "../lib/installStepper/installStepper";
-import * as path from "path";
-import { Adminizer } from "../lib/Adminizer";
-export default async function processInstallStep(req, res) {
-    if (req.adminizer.config.auth.enable) {
-        if (!req.session.UserAP) {
-            res.redirect(`${req.adminizer.config.routePrefix}/model/userap/login`);
-            return;
-        }
-        else if (!req.adminizer.accessRightsHelper.hasPermission(`process-install-step`, req.session.UserAP)) {
-            res.sendStatus(403);
-            return;
-        }
-    }
-    if (req.method.toUpperCase() === 'GET') {
-        Adminizer.log.debug("GET REQUEST TO PROCESS INSTALL STEP");
-        let installStepper = InstallStepper.getStepper(req.params.id);
-        if (!installStepper) {
-            res.redirect(`${req.adminizer.config.routePrefix}/`);
-            return;
-        }
-        if (installStepper.hasUnprocessedSteps() || installStepper.hasUnfinalizedSteps()) {
-            let renderData = installStepper.render(req);
-            let renderer = renderData.currentStep.renderer;
-            // run onInit method before showing step to user
-            try {
-                await renderData.currentStep.onInit();
-            }
-            catch (e) {
-                console.log("ERROR IN PROCESS INSTALL STEP", e);
-                res.viewAdmin(`installer/error`, { error: e, stepperId: installStepper.id });
-                return;
-            }
-            res.viewAdmin(`installer/${renderer}`, { ...renderData, stepperId: installStepper.id });
-            return;
-        }
-        else {
-            res.redirect(`${req.adminizer.config.routePrefix}/`);
-            return;
-        }
-    }
-    if (req.method.toUpperCase() === 'POST') {
-        try {
-            Adminizer.log.debug("POST REQUEST TO PROCESS INSTALL STEP", JSON.stringify(req.body, null, 2));
-            let installStepper = InstallStepper.getStepper(req.params.id);
-            const currentStepId = req.body.currentStepId;
-            const filesCounter = req.body.filesCounter;
-            // upload files before processing other fields (filesCounter > 0 means that req contains files)
-            const uploadedFiles = await handleFileUploads(req, currentStepId, filesCounter);
-            if (req.body.action === 'next') {
-                const inputData = JSON.parse(req.body.inputData);
-                if (uploadedFiles.length) {
-                    inputData.uploadedFiles = uploadedFiles;
-                }
-                // trying to process step
-                await installStepper.processStep(currentStepId, inputData);
-            }
-            else if (req.body.action === 'skip') {
-                // trying to skip step
-                await installStepper.skipStep(currentStepId);
-            }
-            else {
-                res.status(400).send("Invalid action parameter");
-                return;
-            }
-            // go back to stepper if there are more unprocessed steps, otherwise go back to /admin
-            if (installStepper.hasUnprocessedSteps()) {
-                res.redirect(`${req.adminizer.config.routePrefix}/install/${installStepper.id}`);
-                return;
-            }
-            else {
-                res.redirect(`${req.adminizer.config.routePrefix}/`);
-                return;
-            }
-        }
-        catch (error) {
-            Adminizer.log.error("Error processing step:", error);
-            res.status(500).send("Error processing step");
-            return;
-        }
-    }
-    if (req.method.toUpperCase() === 'DELETE') {
-        Adminizer.log.debug("DELETE REQUEST TO PROCESS INSTALL STEP", req.body);
-        try {
-            InstallStepper.deleteStepper(req.params.id);
-            res.status(200).send("OK");
-            return;
-        }
-        catch (e) {
-            res.status(403).send(e);
-            return;
-        }
-    }
-    res.status(500).send("Invalid request method");
-    return;
-}
-;
-async function handleFileUploads(req, currentStepId, filesCounter) {
-    const uploadedFiles = [];
-    for (let i = 0; i < filesCounter; i++) {
-        const fieldName = `files_${i}`;
-        const uploadMiddleware = req.upload({
-            destination: "installStepper/uploadedImages",
-            filename: (file) => {
-                const extension = path.extname(file.originalname);
-                const baseName = path.basename(file.originalname, extension);
-                return `${currentStepId}_${baseName}_${Date.now()}${extension}`;
-            },
-        }).single(fieldName);
-        try {
-            await new Promise((resolve, reject) => {
-                uploadMiddleware(req, null, (err) => {
-                    if (err) {
-                        Adminizer.logger.error(`Error uploading file: ${fieldName}`, err);
-                        reject(err);
-                    }
-                    else {
-                        const uploadedFile = req.file?.path;
-                        if (uploadedFile) {
-                            uploadedFiles.push(uploadedFile);
-                        }
-                        resolve();
-                    }
-                });
-            });
-        }
-        catch (err) {
-            Adminizer.logger.error(`Failed to upload file: ${fieldName}`, err);
-        }
-    }
-    return uploadedFiles;
-}

package/lib/installStepper/InstallStepAbstract.d.ts

@@ -1,52 +0,0 @@
-import { ObservablePromise } from "../observablePromise";
-export default abstract class InstallStepAbstract {
-    abstract id: string;
-    abstract title: string;
-    abstract badge: string;
-    abstract sortOrder: number;
-    /** Step can be skipped. For this option you should do realization for skip handler */
-    abstract canBeSkipped: boolean;
-    abstract description: string;
-    abstract scriptsUrl: string;
-    abstract stylesUrl: string;
-    /** For custom modules to set the list of settings wanted to set in this step */
-    settingsKeys: string[];
-    /** Absolute path to ejs template */
-    abstract ejsPath: string;
-    abstract renderer: "ejs" | "jsonforms";
-    isSkipped: boolean;
-    isProcessed: boolean;
-    /** Data that will be given to browser */
-    payload: any;
-    groupSortOrder: number;
-    finallyPromise: ObservablePromise<void>;
-    finallyDescription: string;
-    /**
-     * A sign that finalization should be started
-     */
-    finallyToRun: boolean;
-    /**
-     * The time it takes for finally to complete
-     *
-     * default: 15 seconds
-     *
-     * maximum: 10 minutes;
-     */
-    finallyTimeout: number;
-    /** Action that will be run when saving data to storage */
-    abstract process(data: any, context?: any): Promise<void>;
-    /** Method will be called after processing step (both process or skip) */
-    finally(data: any, context?: any): Promise<void>;
-    /** This method will be called by InstallStepper and is a wrapper for "finally" method */
-    toFinally(data?: any, context?: any, timeout?: number): void;
-    /** Action that will be run when skipping the step */
-    protected abstract skip(): Promise<void>;
-    /** This method will be called by InstallStepper and is a wrapper for "skip" method */
-    skipIt(): Promise<void>;
-    /**
-     * Checks that step should be processed during install
-     * `true` means that the step has been completed and does not need to be shown
-     */
-    abstract check(): Promise<boolean>;
-    onInit(): Promise<void>;
-}

package/lib/installStepper/InstallStepAbstract.js

@@ -1,69 +0,0 @@
-import { ObservablePromise } from "../observablePromise";
-import { Adminizer } from "../Adminizer";
-export default class InstallStepAbstract {
-    /** For custom modules to set the list of settings wanted to set in this step */
-    settingsKeys = [];
-    isSkipped = false;
-    isProcessed = false;
-    /** Data that will be given to browser */
-    payload = {};
-    groupSortOrder = 1;
-    finallyPromise = null;
-    finallyDescription = null;
-    /**
-     * A sign that finalization should be started
-     */
-    finallyToRun = false;
-    /**
-     * The time it takes for finally to complete
-     *
-     * default: 15 seconds
-     *
-     * maximum: 10 minutes;
-     */
-    finallyTimeout = 15 * 60 * 1000;
-    /** Method will be called after processing step (both process or skip) */
-    finally(data, context) {
-        return null;
-    }
-    /** This method will be called by InstallStepper and is a wrapper for "finally" method */
-    toFinally(data, context, timeout) {
-        Adminizer.log.debug(`To finally [${this.id}]`);
-        if (!timeout) {
-            timeout = this.finallyTimeout;
-        }
-        if (!timeout || typeof timeout !== "number") {
-            timeout = 15 * 60 * 1000;
-        }
-        if (timeout > 10 * 60 * 60 * 1000) {
-            timeout = 10 * 60 * 60 * 1000;
-        }
-        if (typeof arguments[0] === "number") {
-            timeout = arguments[0];
-        }
-        if (this.finallyPromise && this.finallyPromise.status === "pending") {
-            Adminizer.log.warn(`Method "finally" was already executed and won't be executed again`);
-        }
-        else {
-            try {
-                this.finallyPromise = new ObservablePromise(this.finally(data, context), timeout);
-            }
-            catch (error) {
-                Adminizer.log.error(`Step [${this.id}] finally error:`, error);
-            }
-        }
-        this.finallyPromise.promise;
-    }
-    /** This method will be called by InstallStepper and is a wrapper for "skip" method */
-    async skipIt() {
-        if (this.canBeSkipped === false) {
-            throw `Step [${this.title}] can not be skipped`;
-        }
-        else {
-            await this.skip();
-        }
-    }
-    async onInit() {
-        return;
-    }
-}

package/lib/installStepper/finalizeStep.d.ts

@@ -1,21 +0,0 @@
-import InstallStepAbstract from "./InstallStepAbstract";
-export default class FinalizeStep extends InstallStepAbstract {
-    canBeSkipped: boolean;
-    description: string;
-    ejsPath: string;
-    id: string;
-    scriptsUrl: string;
-    sortOrder: number;
-    stylesUrl: string;
-    title: string;
-    badge: string;
-    isSkipped: boolean;
-    settingsKeys: string[];
-    renderer: "ejs";
-    isProcessed: boolean;
-    check(): Promise<boolean>;
-    process(data: any): Promise<void>;
-    skip(): Promise<void>;
-    finally(): Promise<void>;
-    toFinally(): void;
-}

package/lib/installStepper/finalizeStep.js

@@ -1,48 +0,0 @@
-import InstallStepAbstract from "./InstallStepAbstract";
-import * as path from "path";
-import { InstallStepper } from "./installStepper";
-export default class FinalizeStep extends InstallStepAbstract {
-    canBeSkipped = false;
-    description = '';
-    ejsPath = path.resolve(import.meta.dirname, '../../views/ejs/installer/partials/finalize.ejs');
-    id = 'finalize';
-    scriptsUrl = '';
-    sortOrder = 0;
-    stylesUrl = '';
-    title = 'Finalize Step';
-    badge = '';
-    isSkipped = false;
-    settingsKeys = [];
-    renderer = "ejs";
-    isProcessed = false;
-    async check() {
-        if (this.isProcessed) {
-            return true;
-        }
-        else {
-            let installStepper = InstallStepper.getInstance();
-            if (!installStepper.hasUnfinalizedSteps()) {
-                this.canBeSkipped = true;
-            }
-        }
-        return false;
-    }
-    async process(data) {
-        let installStepper = InstallStepper.getInstance();
-        if (!installStepper.hasUnfinalizedSteps()) {
-            this.isProcessed = true;
-        }
-    }
-    async skip() {
-        let installStepper = InstallStepper.getInstance();
-        if (!installStepper.hasUnfinalizedSteps()) {
-            this.isProcessed = true;
-        }
-    }
-    finally() {
-        return Promise.resolve();
-    }
-    toFinally() {
-        return;
-    }
-}

package/lib/installStepper/installStepper.d.ts

@@ -1,40 +0,0 @@
-import InstallStepAbstract from "./InstallStepAbstract";
-interface RenderData {
-    totalStepCount: number;
-    leftStepsCount: number;
-    currentStep: InstallStepAbstract;
-    locale: string;
-}
-export declare class InstallStepper {
-    id: string;
-    private steps;
-    context: any;
-    readonly canBeClosed: boolean;
-    static instances: InstallStepper[];
-    constructor(id: string, canBeClosed?: boolean);
-    static addStepper(stepper?: InstallStepper): void;
-    static getStepper(stepperId: string): InstallStepper;
-    static deleteStepper(stepperId: string): void;
-    static getInstance(): InstallStepper;
-    getSteps(): InstallStepAbstract[];
-    processStep(stepId: string, data: any): Promise<void>;
-    private getStepById;
-    /** Prepares steps array for user interface render */
-    render(req: ReqType): RenderData;
-    skipStep(stepId: string): Promise<void>;
-    /** Add step (replace if it already exists) */
-    addStep(step: InstallStepAbstract): void;
-    hasUnprocessedSteps(): boolean;
-    getNextUnprocessedStep(): InstallStepAbstract;
-    hasUnfinalizedSteps(): boolean;
-    getFinalizeStatus(): {
-        status: string;
-        finalizeList: {
-            id: string;
-            status: "pending" | "fulfilled" | "rejected";
-            description: string;
-            info: string;
-        }[];
-    };
-}
-export {};

package/lib/installStepper/installStepper.js

@@ -1,195 +0,0 @@
-import FinalizeStep from "./finalizeStep";
-import * as fs from "fs";
-import { TranslationHelper } from "../../helpers/translationHelper";
-import { Adminizer } from "../Adminizer";
-export class InstallStepper {
-    id;
-    steps = [];
-    context = {};
-    canBeClosed;
-    // TODO remove static fields for multi adminizer server
-    static instances = [];
-    constructor(id, canBeClosed = false) {
-        this.id = id;
-        this.canBeClosed = canBeClosed;
-    }
-    static addStepper(stepper) {
-        if (this.instances.find(item => item.id === stepper.id)) {
-            Adminizer.log.debug(`Stepper with id ${stepper.id} was deleted due to creating new one`);
-            this.deleteStepper(stepper.id);
-        }
-        this.instances.push(stepper);
-    }
-    static getStepper(stepperId) {
-        return this.instances.find(item => item.id === stepperId);
-    }
-    static deleteStepper(stepperId) {
-        let stepper = this.getStepper(stepperId);
-        if (!stepper.canBeClosed) {
-            Adminizer.log.error(`Can not delete stepper: Stepper with id ${stepperId} can not be closed.`);
-            throw `Can not delete stepper: Stepper with id ${stepperId} can not be closed`;
-        }
-        const index = this.instances.findIndex(item => item.id === stepperId);
-        if (index !== -1) {
-            this.instances.splice(index, 1);
-            Adminizer.log.info(`Stepper with id ${stepperId} has been deleted.`);
-        }
-        else {
-            Adminizer.log.error(`Can not delete stepper: Stepper with id ${stepperId} not found.`);
-            throw `Can not delete stepper: Stepper with id ${stepperId} not found.`;
-        }
-    }
-    static getInstance() {
-        if (!this.instances.length) {
-            let newStepper = new InstallStepper("project", false);
-            this.instances.push(newStepper);
-        }
-        return this.instances.find(item => item.id === "project");
-    }
-    getSteps() {
-        return this.steps;
-    }
-    async processStep(stepId, data) {
-        try {
-            /** As we sort steps by sortOrder, we should check that previous steps were processed */
-            const stepIndex = this.steps.findIndex(item => item.id === stepId);
-            Adminizer.log.debug("STEP INDEX", stepIndex);
-            for (let i = 0; i < stepIndex; i++) {
-                if (this.steps[i].canBeSkipped && this.steps[i].isSkipped) {
-                    continue;
-                }
-                let checkResult = await this.steps[i].check();
-                if (checkResult === false) {
-                    throw `Previous step was not processed`;
-                }
-            }
-            let step = this.getStepById(stepId);
-            // get context copy and write down information in it on process without damaging source object
-            let contextCopy = { ...this.context };
-            await step.process(data, contextCopy);
-            Object.assign(this.context, contextCopy);
-            step.isProcessed = true;
-            Adminizer.log.debug(`STEP ${stepId} was processed`);
-            // call finalize method only if has description
-            if (step.finallyToRun) {
-                contextCopy = { ...this.context };
-                step.toFinally(data, this.context);
-                Object.assign(this.context, contextCopy);
-            }
-        }
-        catch (e) {
-            Adminizer.log.error(`Error processing step: ${e}`);
-            throw new Error(e);
-        }
-    }
-    getStepById(stepId) {
-        return this.steps.find(item => item.id === stepId);
-    }
-    /** Prepares steps array for user interface render */
-    render(req) {
-        let stepToRender = this.getNextUnprocessedStep();
-        let leftSteps = this.steps.filter(step => !step.isProcessed && !step.isSkipped);
-        // set locale
-        if (typeof req.adminizer.config.translation !== "boolean") {
-            if (!req.session.UserAP.locale || !req.adminizer.config.translation.locales.includes(req.session.UserAP.locale)) {
-                req.session.UserAP.locale = req.adminizer.config.translation.defaultLocale || "en";
-            }
-        }
-        else {
-            req.session.UserAP.locale = "en";
-        }
-        this.context.locale = req.session.UserAP.locale;
-        // translate step
-        stepToRender = TranslationHelper.translateProperties(req.i18n, stepToRender, ["title", "description", "name"]);
-        return {
-            totalStepCount: this.steps.length,
-            leftStepsCount: leftSteps.length,
-            currentStep: stepToRender,
-            locale: req.session.UserAP.locale
-        };
-    }
-    async skipStep(stepId) {
-        try {
-            let step = this.getStepById(stepId);
-            await step.skipIt();
-            step.isSkipped = true;
-        }
-        catch (e) {
-            Adminizer.log.error(`Error skipping step: ${e}`);
-        }
-    }
-    /** Add step (replace if it already exists) */
-    addStep(step) {
-        if (step.renderer === "ejs") {
-            if (!step.ejsPath || !fs.existsSync(step.ejsPath)) {
-                throw `Step [${step.title}] error: ejs path does not exists`;
-            }
-        }
-        const stepIndex = this.steps.findIndex(item => item.id === step.id);
-        if (stepIndex !== -1) {
-            Adminizer.log.warn(`Attention! The step has been replaced\`${step.id}\``);
-            this.steps[stepIndex] = step;
-        }
-        else {
-            this.steps.push(step);
-        }
-        // sort by group, then by renderer and then by sortOrder
-        this.steps.sort((a, b) => {
-            if (a.groupSortOrder !== b.groupSortOrder) {
-                return a.groupSortOrder - b.groupSortOrder;
-            }
-            else {
-                if (a.renderer !== b.renderer) {
-                    return a.renderer === 'ejs' ? -1 : 1;
-                }
-                else {
-                    return a.sortOrder - b.sortOrder;
-                }
-            }
-        });
-    }
-    hasUnprocessedSteps() {
-        return this.steps.some(step => !step.isProcessed && !step.isSkipped);
-    }
-    getNextUnprocessedStep() {
-        let nextStep = this.steps.find(step => !step.isProcessed && !step.isSkipped);
-        if (!nextStep && this.hasUnfinalizedSteps()) {
-            if (this.getStepById("finalize")) {
-                nextStep = this.getStepById("finalize");
-            }
-            else {
-                let timer = setInterval(() => {
-                    // clear steps if all of them was processed and finalized
-                    if (!this.hasUnprocessedSteps() && !this.hasUnfinalizedSteps()) {
-                        this.steps = [];
-                        Adminizer.log.debug("CLEARING STEPS", this.steps);
-                        clearInterval(timer);
-                    }
-                }, 5000);
-                nextStep = new FinalizeStep();
-                this.addStep(nextStep);
-            }
-        }
-        return nextStep;
-    }
-    hasUnfinalizedSteps() {
-        return this.steps.some(step => step.finallyPromise?.status === "pending");
-    }
-    getFinalizeStatus() {
-        let stepsWithFinalize = this.steps.filter(step => step.finallyPromise !== null);
-        let generalStatus = "fulfilled";
-        let stepFinalizeStatuses = stepsWithFinalize.map(item => {
-            let info = null;
-            // if one of them is pending, general status is pending
-            if (item.finallyPromise.status === "pending") {
-                generalStatus = "pending";
-            }
-            if (item.finallyPromise.status === "rejected") {
-                generalStatus = "rejected";
-                info = `Error: ${item.finallyPromise.info}`;
-            }
-            return { id: item.id, status: item.finallyPromise.status, description: item.finallyDescription, info: info };
-        });
-        return { status: generalStatus, finalizeList: stepFinalizeStatuses ?? [] };
-    }
-}

package/models/MediaManagerAP.d.ts

@@ -1,46 +0,0 @@
-declare const _default: {
-    id: {
-        type: string;
-        allowNull: boolean;
-        uuid: boolean;
-        primaryKey: boolean;
-        required: boolean;
-    };
-    parent: {
-        model: string;
-    };
-    variants: {
-        collection: string;
-        via: string;
-    };
-    mimeType: {
-        type: string;
-    };
-    path: {
-        type: string;
-    };
-    size: {
-        type: string;
-    };
-    group: {
-        type: string;
-    };
-    tag: {
-        type: string;
-    };
-    url: {
-        type: string;
-    };
-    filename: {
-        type: string;
-    };
-    meta: {
-        collection: string;
-        via: string;
-    };
-    modelAssociation: {
-        collection: string;
-        via: string;
-    };
-};
-export default _default;

package/models/MediaManagerAP.js

@@ -1,45 +0,0 @@
-export default {
-    id: {
-        type: "string",
-        allowNull: false,
-        uuid: true,
-        primaryKey: true,
-        required: true
-    },
-    parent: {
-        model: "MediaManagerAP"
-    },
-    variants: {
-        collection: "MediaManagerAP",
-        via: "parent"
-    },
-    mimeType: {
-        type: "string"
-    },
-    path: {
-        type: "string"
-    },
-    size: {
-        type: "number"
-    },
-    group: {
-        type: "string"
-    },
-    tag: {
-        type: "string"
-    },
-    url: {
-        type: "string"
-    },
-    filename: {
-        type: "string"
-    },
-    meta: {
-        collection: "MediaManagerMetaAP",
-        via: "parent"
-    },
-    modelAssociation: {
-        collection: "MediaManagerAssociationsAP",
-        via: "file"
-    }
-};

package/models/MediaManagerAssociationsAP.d.ts

@@ -1,28 +0,0 @@
-declare const _default: {
-    id: {
-        type: string;
-        allowNull: boolean;
-        uuid: boolean;
-        primaryKey: boolean;
-        required: boolean;
-    };
-    mediaManagerId: {
-        type: string;
-    };
-    model: {
-        type: string;
-    };
-    modelId: {
-        type: string;
-    };
-    widgetName: {
-        type: string;
-    };
-    sortOrder: {
-        type: string;
-    };
-    file: {
-        model: string;
-    };
-};
-export default _default;