@acorex/modules 20.3.0-next.19 → 20.3.0-next.20

package/fesm2022/acorex-modules-common.mjs

@@ -699,9 +699,10 @@ class AXPEntityBulkArchiveAction extends AXPWorkflowAction {
     }
     async execute(context) {
         const refType = context.getVariable('options.refType');
-        const selectedIds = context.getVariable('selectedIds') || [];
+        const data = context.getVariable('data');
+        const selectedIds = Array.isArray(data) ? data.map((c) => c.id) : data ? [data.id] : [];
         if (!refType || selectedIds.length === 0) {
-            throw new Error('Missing required parameters: refType and selectedIds');
+            throw new Error('Missing required parameters: refType and data');
         }
         const [moduleName, entityName] = refType.split('.');
         const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
@@ -859,9 +860,10 @@ class AXPEntityBulkUnarchiveAction extends AXPWorkflowAction {
     }
     async execute(context) {
         const refType = context.getVariable('options.refType');
-        const selectedIds = context.getVariable('selectedIds') || [];
+        const data = context.getVariable('data');
+        const selectedIds = Array.isArray(data) ? data.map((c) => c.id) : data ? [data.id] : [];
         if (!refType || selectedIds.length === 0) {
-            throw new Error('Missing required parameters: refType and selectedIds');
+            throw new Error('Missing required parameters: refType and data');
         }
         const [moduleName, entityName] = refType.split('.');
         const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
@@ -1680,6 +1682,909 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImpor
                 }]
         }] });
 
+const disablePlugin = {
+    name: 'disable',
+    order: 70,
+    apply: (ctx) => {
+        ensureListActions(ctx);
+        //#region ----   Add isDisabled Property   ----
+        // Ensure settings group exists
+        const groupId = 'settings';
+        const groups = ctx.groups.list() ?? [];
+        if (!groups.some((g) => g.id === groupId)) {
+            ctx.groups.add({ id: groupId, title: '@general:terms.interface.settings' });
+        }
+        // Add isDisabled property if it doesn't exist
+        const props = ctx.properties.list();
+        if (!props.some((p) => p.name === 'isDisabled')) {
+            ctx.properties.add({
+                name: 'isDisabled',
+                title: '@general:terms.status.states.is-disabled',
+                groupId,
+                schema: {
+                    dataType: 'boolean',
+                    interface: {
+                        type: AXPWidgetsList.Editors.ToggleSwitch,
+                        options: {
+                            // Default to false (not disabled)
+                            defaultValue: false,
+                            // trulyText: '@general:terms.disabled',
+                            // falsyText: '@general:terms.enabled',
+                            negative: true,
+                            nullValue: false,
+                        },
+                    },
+                },
+                validations: [],
+                options: {
+                    sort: { enabled: true },
+                    filter: {
+                        advance: { enabled: true },
+                        inline: { enabled: true }
+                    }
+                }
+            });
+        }
+        // Add isDisabled to columns for list view
+        const columns = ctx.columns.list() ?? [];
+        if (!columns.some((c) => c.name === 'isDisabled')) {
+            ctx.columns.add({
+                name: 'isDisabled',
+                title: '@general:terms.status.states.is-enabled',
+                width: 100,
+                sortable: true,
+                filterable: true,
+            });
+        }
+        //#endregion
+        //#region ----   Add Disable Actions   ----
+        ctx.interfaces.update((i) => {
+            const disableCmdName = 'disable-entity';
+            const enableCmdName = 'enable-entity';
+            const bulkDisableCmdName = 'bulk-disable-entity';
+            const bulkEnableCmdName = 'bulk-enable-entity';
+            // Add disable action to list view
+            const listActions = i.master.list.actions;
+            if (!actionExists(listActions, disableCmdName)) {
+                listActions.push({
+                    title: '@general:actions.disable.title',
+                    command: {
+                        name: disableCmdName,
+                        options: {
+                            refId: '{{ context.eval("id") }}',
+                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
+                        },
+                    },
+                    priority: 'secondary',
+                    type: 'disable',
+                    icon: 'fa-light fa-ban',
+                    scope: AXPEntityCommandScope.Individual,
+                    hidden: `{{ context.eval("isDisabled") }}`,
+                });
+            }
+            // Add enable action to list view
+            if (!actionExists(listActions, enableCmdName)) {
+                listActions.push({
+                    title: '@general:actions.enable.title',
+                    command: {
+                        name: enableCmdName,
+                        options: {
+                            refId: '{{ context.eval("id") }}',
+                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
+                        },
+                    },
+                    priority: 'secondary',
+                    type: 'enable',
+                    icon: 'fa-light fa-check',
+                    scope: AXPEntityCommandScope.Individual,
+                    hidden: `{{ !context.eval("isDisabled") }}`,
+                });
+            }
+            // Add bulk disable action to list view
+            if (!actionExists(listActions, bulkDisableCmdName)) {
+                listActions.push({
+                    title: '@general:actions.bulk-disable.title',
+                    command: {
+                        name: bulkDisableCmdName,
+                        options: {
+                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
+                        },
+                    },
+                    priority: 'secondary',
+                    type: 'disable',
+                    icon: 'fa-light fa-ban',
+                    scope: AXPEntityCommandScope.Selected,
+                });
+            }
+            // Add bulk enable action to list view
+            if (!actionExists(listActions, bulkEnableCmdName)) {
+                listActions.push({
+                    title: '@general:actions.bulk-enable.title',
+                    command: {
+                        name: bulkEnableCmdName,
+                        options: {
+                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
+                        },
+                    },
+                    priority: 'secondary',
+                    type: 'enable',
+                    icon: 'fa-light fa-check',
+                    scope: AXPEntityCommandScope.Selected,
+                });
+            }
+            // Add disable action to single view
+            const singleActions = i.master?.single?.actions || [];
+            if (!actionExists(singleActions, disableCmdName)) {
+                singleActions.push({
+                    title: '@general:actions.disable.title',
+                    command: {
+                        name: disableCmdName,
+                        options: {
+                            refId: '{{ context.eval("id") }}',
+                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
+                        },
+                    },
+                    priority: 'secondary',
+                    type: 'disable',
+                    icon: 'fa-light fa-ban',
+                    scope: AXPEntityCommandScope.Individual,
+                    hidden: `{{ context.eval("isDisabled") }}`,
+                });
+            }
+            // Add enable action to single view
+            if (!actionExists(singleActions, enableCmdName)) {
+                singleActions.push({
+                    title: '@general:actions.enable.title',
+                    command: {
+                        name: enableCmdName,
+                        options: {
+                            refId: '{{ context.eval("id") }}',
+                            refType: `${ctx.entity.module}.${ctx.entity.name}`,
+                        },
+                    },
+                    priority: 'secondary',
+                    type: 'enable',
+                    icon: 'fa-light fa-check',
+                    scope: AXPEntityCommandScope.Individual,
+                    hidden: `{{ !context.eval("isDisabled") }}`,
+                });
+            }
+            return i;
+        });
+        //#endregion
+        //#region ----   Update Interface Layouts   ----
+        // Ensure update view includes isDisabled
+        ctx.interfaces.master.modify.update((update) => {
+            const next = update ?? { sections: [], properties: [] };
+            next.sections = next.sections ?? [];
+            if (!next.sections.some((s) => s.id === groupId)) {
+                next.sections.push({ id: groupId });
+            }
+            next.properties = next.properties ?? [];
+            if (!next.properties.some((p) => p.name === 'isDisabled')) {
+                next.properties.push({
+                    name: 'isDisabled',
+                    layout: {
+                        positions: { lg: { colSpan: 6, order: 95 } },
+                    },
+                });
+            }
+            return next;
+        });
+        // Ensure single view includes isDisabled
+        ctx.interfaces.master.single.update((single) => {
+            const next = single ?? { title: ctx.entity.title, sections: [], properties: [] };
+            next.sections = next.sections ?? [];
+            if (!next.sections.some((s) => s.id === groupId)) {
+                next.sections.push({ id: groupId, order: 150 });
+            }
+            next.properties = next.properties ?? [];
+            if (!next.properties.some((p) => p.name === 'isDisabled')) {
+                next.properties.push({
+                    name: 'isDisabled',
+                    layout: {
+                        positions: { lg: { colSpan: 6, order: 95 } },
+                    },
+                });
+            }
+            return next;
+        });
+        // Add disabled view to show only disabled items
+        ctx.interfaces.master.list.update((list) => {
+            const next = list ?? { actions: [], views: [] };
+            next.views = next.views ?? [];
+            // Check if disabled view already exists
+            if (!next.views.some((v) => v.name === 'disabled')) {
+                next.views.push(createQueryView('disabled', '@general:terms.status.states.is-disabled', false, {
+                    conditions: [
+                        {
+                            name: 'isDisabled',
+                            operator: { type: 'equal' },
+                            value: true,
+                            hidden: true
+                        },
+                    ],
+                    sorts: [
+                        { name: 'disabledAt', dir: 'desc' },
+                        { name: 'title', dir: 'asc' },
+                    ],
+                }));
+            }
+            return next;
+        });
+        //#endregion
+    },
+};
+
+const AXPEntityDisabledEvent = createWorkFlowEvent('[Entity] Disabled');
+class AXPEntityDisableAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.entityRegistery = inject(AXPEntityDefinitionRegistryService);
+        this.dialogService = inject(AXDialogService);
+        this.loadingDialog = inject(AXLoadingDialogService);
+        this.translationService = inject(AXTranslationService);
+    }
+    async execute(context) {
+        const refId = context.getVariable('options.refId');
+        const refType = context.getVariable('options.refType');
+        if (!refId || !refType) {
+            throw new Error('Missing required parameters: refId and refType');
+        }
+        const [moduleName, entityName] = refType.split('.');
+        const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
+        // Show confirmation dialog
+        const dialogResult = await this.dialogService.confirm(await this.translationService.translateAsync('@general:actions.disable.confirm.title'), await this.translationService.translateAsync('@general:actions.disable.confirm.message'), 'warning', 'horizontal', false, 'cancel');
+        if (!dialogResult.result) {
+            context.setOutput('isCanceled', true);
+            context.setOutput('error', 'Operation cancelled by user');
+            return;
+        }
+        // Show loading dialog
+        const loadingDialog = this.loadingDialog.show({
+            title: await this.translationService.translateAsync('@general:actions.disable.confirm.processing'),
+            mode: 'indeterminate',
+            status: 'Disabling...',
+        });
+        try {
+            // Get the current entity data
+            const currentData = await this.getEntityData(refType, refId);
+            // Prepare disable data
+            const disableData = this.prepareDisableData(currentData);
+            // Update the entity to mark it as disabled
+            if (entityDefinition.commands?.update) {
+                const updateExec = entityDefinition.commands.update.execute;
+                await updateExec(disableData);
+                context.setOutput('id', refId);
+                context.setOutput('isCanceled', false);
+                // Set refresh metadata
+                if (entityDefinition.parentKey && currentData[entityDefinition.parentKey]) {
+                    context.setVariable('meta', { refreshTargetId: currentData[entityDefinition.parentKey] });
+                }
+            }
+            else {
+                throw new Error('Entity does not support update operation');
+            }
+        }
+        catch (error) {
+            console.error('Disable operation failed:', error);
+            context.setOutput('error', error instanceof Error ? error.message : 'Unknown error');
+            context.setOutput('isCanceled', true);
+        }
+        finally {
+            loadingDialog.close();
+        }
+    }
+    async getEntityData(refType, refId) {
+        try {
+            // Use the entity's byKey query to get actual data
+            const [moduleName, entityName] = refType.split('.');
+            const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
+            if (entityDefinition.queries?.byKey) {
+                const queryExec = entityDefinition.queries.byKey.execute;
+                return await queryExec(refId);
+            }
+            // Fallback to basic structure if no query available
+            return { id: refId };
+        }
+        catch (error) {
+            console.error('Failed to retrieve entity data:', error);
+            throw new Error(`Failed to retrieve entity data: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    prepareDisableData(currentData) {
+        const disableData = { ...currentData };
+        // Set the disabled flag
+        disableData.isDisabled = true;
+        // Optionally add disable timestamp
+        disableData.disabledAt = new Date();
+        return disableData;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityDisableAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityDisableAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityDisableAction, decorators: [{
+            type: Injectable
+        }] });
+class AXPEntityDisableSuccessAction extends AXPWorkflowAction {
+    async execute(context) {
+        const refType = context.getVariable('options.refType');
+        const id = context.getOutput('id');
+        const meta = context.getVariable('meta');
+        // Dispatch disable event
+        this.dispatch(AXPEntityDisabledEvent({
+            entity: refType,
+            id,
+            meta
+        }));
+        // Refresh the entity list
+        this.dispatch(AXPRefreshEvent({
+            entity: refType,
+            meta
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityDisableSuccessAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityDisableSuccessAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityDisableSuccessAction, decorators: [{
+            type: Injectable
+        }] });
+const AXPDisableEntityWorkflow = {
+    startStepId: 'disable-entity',
+    steps: {
+        'disable-entity': {
+            action: 'AXPEntityDisableAction',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("isCanceled") == false' }],
+                    nextStepId: 'show-success-toast',
+                },
+            ],
+        },
+        'show-success-toast': {
+            action: 'AXPToastAction',
+            input: {
+                color: 'success',
+                title: 'workflow.entity-disabled',
+                content: 'workflow.entity-disabled-body',
+            },
+            nextSteps: [
+                {
+                    conditions: [],
+                    nextStepId: 'disable-success',
+                },
+            ],
+        },
+        'disable-success': {
+            action: 'AXPEntityDisableSuccessAction',
+        },
+    },
+};
+
+const AXPEntityEnabledEvent = createWorkFlowEvent('[Entity] Enabled');
+class AXPEntityEnableAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.entityRegistery = inject(AXPEntityDefinitionRegistryService);
+        this.dialogService = inject(AXDialogService);
+        this.loadingDialog = inject(AXLoadingDialogService);
+        this.translationService = inject(AXTranslationService);
+    }
+    async execute(context) {
+        const refId = context.getVariable('options.refId');
+        const refType = context.getVariable('options.refType');
+        if (!refId || !refType) {
+            throw new Error('Missing required parameters: refId and refType');
+        }
+        const [moduleName, entityName] = refType.split('.');
+        const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
+        // Show confirmation dialog
+        const dialogResult = await this.dialogService.confirm(await this.translationService.translateAsync('@general:actions.enable.confirm.title'), await this.translationService.translateAsync('@general:actions.enable.confirm.message'), 'success', 'horizontal', false, 'cancel');
+        if (!dialogResult.result) {
+            context.setOutput('isCanceled', true);
+            context.setOutput('error', 'Operation cancelled by user');
+            return;
+        }
+        // Show loading dialog
+        const loadingDialog = this.loadingDialog.show({
+            title: await this.translationService.translateAsync('@general:actions.enable.confirm.processing'),
+            mode: 'indeterminate',
+            status: 'Enabling...',
+        });
+        try {
+            // Get the current entity data
+            const currentData = await this.getEntityData(refType, refId);
+            // Prepare enable data
+            const enableData = this.prepareEnableData(currentData);
+            // Update the entity to mark it as enabled
+            if (entityDefinition.commands?.update) {
+                const updateExec = entityDefinition.commands.update.execute;
+                await updateExec(enableData);
+                context.setOutput('id', refId);
+                context.setOutput('isCanceled', false);
+                // Set refresh metadata
+                if (entityDefinition.parentKey && currentData[entityDefinition.parentKey]) {
+                    context.setVariable('meta', { refreshTargetId: currentData[entityDefinition.parentKey] });
+                }
+            }
+            else {
+                throw new Error('Entity does not support update operation');
+            }
+        }
+        catch (error) {
+            console.error('Enable operation failed:', error);
+            context.setOutput('error', error instanceof Error ? error.message : 'Unknown error');
+            context.setOutput('isCanceled', true);
+        }
+        finally {
+            loadingDialog.close();
+        }
+    }
+    async getEntityData(refType, refId) {
+        try {
+            // Use the entity's byKey query to get actual data
+            const [moduleName, entityName] = refType.split('.');
+            const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
+            if (entityDefinition.queries?.byKey) {
+                const queryExec = entityDefinition.queries.byKey.execute;
+                return await queryExec(refId);
+            }
+            // Fallback to basic structure if no query available
+            return { id: refId };
+        }
+        catch (error) {
+            console.error('Failed to retrieve entity data:', error);
+            throw new Error(`Failed to retrieve entity data: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    prepareEnableData(currentData) {
+        const enableData = { ...currentData };
+        // Set the disabled flag to false
+        enableData.isDisabled = false;
+        // Optionally add enable timestamp
+        enableData.enabledAt = new Date();
+        return enableData;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityEnableAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityEnableAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityEnableAction, decorators: [{
+            type: Injectable
+        }] });
+class AXPEntityEnableSuccessAction extends AXPWorkflowAction {
+    async execute(context) {
+        const refType = context.getVariable('options.refType');
+        const id = context.getOutput('id');
+        const meta = context.getVariable('meta');
+        // Dispatch enable event
+        this.dispatch(AXPEntityEnabledEvent({
+            entity: refType,
+            id,
+            meta
+        }));
+        // Refresh the entity list
+        this.dispatch(AXPRefreshEvent({
+            entity: refType,
+            meta
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityEnableSuccessAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityEnableSuccessAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityEnableSuccessAction, decorators: [{
+            type: Injectable
+        }] });
+const AXPEnableEntityWorkflow = {
+    startStepId: 'enable-entity',
+    steps: {
+        'enable-entity': {
+            action: 'AXPEntityEnableAction',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("isCanceled") == false' }],
+                    nextStepId: 'show-success-toast',
+                },
+            ],
+        },
+        'show-success-toast': {
+            action: 'AXPToastAction',
+            input: {
+                color: 'success',
+                title: 'workflow.entity-enabled',
+                content: 'workflow.entity-enabled-body',
+            },
+            nextSteps: [
+                {
+                    conditions: [],
+                    nextStepId: 'enable-success',
+                },
+            ],
+        },
+        'enable-success': {
+            action: 'AXPEntityEnableSuccessAction',
+        },
+    },
+};
+
+const AXPEntityBulkDisabledEvent = createWorkFlowEvent('[Entity] Bulk Disabled');
+class AXPEntityBulkDisableAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.entityRegistery = inject(AXPEntityDefinitionRegistryService);
+        this.dialogService = inject(AXDialogService);
+        this.loadingDialog = inject(AXLoadingDialogService);
+        this.translationService = inject(AXTranslationService);
+    }
+    async execute(context) {
+        const refType = context.getVariable('options.refType');
+        const data = context.getVariable('data');
+        const selectedIds = Array.isArray(data) ? data.map((c) => c.id) : data ? [data.id] : [];
+        if (!refType || selectedIds.length === 0) {
+            throw new Error('Missing required parameters: refType and data');
+        }
+        const [moduleName, entityName] = refType.split('.');
+        const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
+        // Show confirmation dialog
+        const dialogResult = await this.dialogService.confirm(await this.translationService.translateAsync('@general:actions.bulk-disable.confirm.title'), await this.translationService.translateAsync('@general:actions.bulk-disable.confirm.message', {
+            params: { count: selectedIds.length }
+        }), 'warning', 'horizontal', false, 'cancel');
+        if (!dialogResult.result) {
+            context.setOutput('isCanceled', true);
+            context.setOutput('error', 'Operation cancelled by user');
+            return;
+        }
+        // Show loading dialog
+        const loadingDialog = this.loadingDialog.show({
+            title: await this.translationService.translateAsync('@general:actions.bulk-disable.confirm.processing'),
+            mode: 'indeterminate',
+            status: 'Disabling items...',
+        });
+        try {
+            const results = [];
+            const errors = [];
+            // Process each selected item
+            for (const refId of selectedIds) {
+                try {
+                    // Get the current entity data
+                    const currentData = await this.getEntityData(refType, refId);
+                    // Prepare disable data
+                    const disableData = this.prepareDisableData(currentData);
+                    // Update the entity to mark it as disabled
+                    if (entityDefinition.commands?.update) {
+                        const updateExec = entityDefinition.commands.update.execute;
+                        await updateExec(disableData);
+                        results.push(refId);
+                    }
+                    else {
+                        throw new Error('Entity does not support update operation');
+                    }
+                }
+                catch (error) {
+                    console.error(`Failed to disable entity ${refId}:`, error);
+                    errors.push({ id: refId, error: error instanceof Error ? error.message : 'Unknown error' });
+                }
+            }
+            context.setOutput('processedIds', results);
+            context.setOutput('errors', errors);
+            context.setOutput('isCanceled', false);
+        }
+        catch (error) {
+            console.error('Bulk disable operation failed:', error);
+            context.setOutput('error', error instanceof Error ? error.message : 'Unknown error');
+            context.setOutput('isCanceled', true);
+        }
+        finally {
+            loadingDialog.close();
+        }
+    }
+    async getEntityData(refType, refId) {
+        try {
+            // Use the entity's byKey query to get actual data
+            const [moduleName, entityName] = refType.split('.');
+            const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
+            if (entityDefinition.queries?.byKey) {
+                const queryExec = entityDefinition.queries.byKey.execute;
+                return await queryExec(refId);
+            }
+            // Fallback to basic structure if no query available
+            return { id: refId };
+        }
+        catch (error) {
+            console.error('Failed to retrieve entity data:', error);
+            throw new Error(`Failed to retrieve entity data: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    prepareDisableData(currentData) {
+        const disableData = { ...currentData };
+        // Set the disabled flag
+        disableData.isDisabled = true;
+        // Optionally add disable timestamp
+        disableData.disabledAt = new Date();
+        return disableData;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityBulkDisableAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityBulkDisableAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityBulkDisableAction, decorators: [{
+            type: Injectable
+        }] });
+class AXPEntityBulkDisableSuccessAction extends AXPWorkflowAction {
+    async execute(context) {
+        const refType = context.getVariable('options.refType');
+        const processedIds = context.getOutput('processedIds') || [];
+        const errors = context.getOutput('errors') || [];
+        const meta = context.getVariable('meta');
+        // Dispatch bulk disable event
+        this.dispatch(AXPEntityBulkDisabledEvent({
+            entity: refType,
+            ids: processedIds,
+            meta
+        }));
+        // Refresh the entity list
+        this.dispatch(AXPRefreshEvent({
+            entity: refType,
+            meta
+        }));
+        // Show error summary if there were any errors
+        if (errors.length > 0) {
+            const errorMessage = errors.map(e => `${e.id}: ${e.error}`).join('\n');
+            console.warn('Some items failed to disable:', errorMessage);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityBulkDisableSuccessAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityBulkDisableSuccessAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityBulkDisableSuccessAction, decorators: [{
+            type: Injectable
+        }] });
+const AXPBulkDisableEntityWorkflow = {
+    startStepId: 'bulk-disable-entity',
+    steps: {
+        'bulk-disable-entity': {
+            action: 'AXPEntityBulkDisableAction',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("isCanceled") == false' }],
+                    nextStepId: 'show-success-toast',
+                },
+            ],
+        },
+        'show-success-toast': {
+            action: 'AXPToastAction',
+            input: {
+                color: 'success',
+                title: 'workflow.entity-bulk-disabled',
+                content: 'workflow.entity-bulk-disabled-body',
+            },
+            nextSteps: [
+                {
+                    conditions: [],
+                    nextStepId: 'bulk-disable-success',
+                },
+            ],
+        },
+        'bulk-disable-success': {
+            action: 'AXPEntityBulkDisableSuccessAction',
+        },
+    },
+};
+
+const AXPEntityBulkEnabledEvent = createWorkFlowEvent('[Entity] Bulk Enabled');
+class AXPEntityBulkEnableAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.entityRegistery = inject(AXPEntityDefinitionRegistryService);
+        this.dialogService = inject(AXDialogService);
+        this.loadingDialog = inject(AXLoadingDialogService);
+        this.translationService = inject(AXTranslationService);
+    }
+    async execute(context) {
+        const refType = context.getVariable('options.refType');
+        const data = context.getVariable('data');
+        const selectedIds = Array.isArray(data) ? data.map((c) => c.id) : data ? [data.id] : [];
+        if (!refType || selectedIds.length === 0) {
+            throw new Error('Missing required parameters: refType and data');
+        }
+        const [moduleName, entityName] = refType.split('.');
+        const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
+        // Show confirmation dialog
+        const dialogResult = await this.dialogService.confirm(await this.translationService.translateAsync('@general:actions.bulk-enable.confirm.title'), await this.translationService.translateAsync('@general:actions.bulk-enable.confirm.message', {
+            params: { count: selectedIds.length }
+        }), 'success', 'horizontal', false, 'cancel');
+        if (!dialogResult.result) {
+            context.setOutput('isCanceled', true);
+            context.setOutput('error', 'Operation cancelled by user');
+            return;
+        }
+        // Show loading dialog
+        const loadingDialog = this.loadingDialog.show({
+            title: await this.translationService.translateAsync('@general:actions.bulk-enable.confirm.processing'),
+            mode: 'indeterminate',
+            status: 'Enabling items...',
+        });
+        try {
+            const results = [];
+            const errors = [];
+            // Process each selected item
+            for (const refId of selectedIds) {
+                try {
+                    // Get the current entity data
+                    const currentData = await this.getEntityData(refType, refId);
+                    // Prepare enable data
+                    const enableData = this.prepareEnableData(currentData);
+                    // Update the entity to mark it as enabled
+                    if (entityDefinition.commands?.update) {
+                        const updateExec = entityDefinition.commands.update.execute;
+                        await updateExec(enableData);
+                        results.push(refId);
+                    }
+                    else {
+                        throw new Error('Entity does not support update operation');
+                    }
+                }
+                catch (error) {
+                    console.error(`Failed to enable entity ${refId}:`, error);
+                    errors.push({ id: refId, error: error instanceof Error ? error.message : 'Unknown error' });
+                }
+            }
+            context.setOutput('processedIds', results);
+            context.setOutput('errors', errors);
+            context.setOutput('isCanceled', false);
+        }
+        catch (error) {
+            console.error('Bulk enable operation failed:', error);
+            context.setOutput('error', error instanceof Error ? error.message : 'Unknown error');
+            context.setOutput('isCanceled', true);
+        }
+        finally {
+            loadingDialog.close();
+        }
+    }
+    async getEntityData(refType, refId) {
+        try {
+            // Use the entity's byKey query to get actual data
+            const [moduleName, entityName] = refType.split('.');
+            const entityDefinition = await this.entityRegistery.resolve(moduleName, entityName);
+            if (entityDefinition.queries?.byKey) {
+                const queryExec = entityDefinition.queries.byKey.execute;
+                return await queryExec(refId);
+            }
+            // Fallback to basic structure if no query available
+            return { id: refId };
+        }
+        catch (error) {
+            console.error('Failed to retrieve entity data:', error);
+            throw new Error(`Failed to retrieve entity data: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    prepareEnableData(currentData) {
+        const enableData = { ...currentData };
+        // Set the disabled flag to false
+        enableData.isDisabled = false;
+        // Optionally add enable timestamp
+        enableData.enabledAt = new Date();
+        return enableData;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityBulkEnableAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityBulkEnableAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityBulkEnableAction, decorators: [{
+            type: Injectable
+        }] });
+class AXPEntityBulkEnableSuccessAction extends AXPWorkflowAction {
+    async execute(context) {
+        const refType = context.getVariable('options.refType');
+        const processedIds = context.getOutput('processedIds') || [];
+        const errors = context.getOutput('errors') || [];
+        const meta = context.getVariable('meta');
+        // Dispatch bulk enable event
+        this.dispatch(AXPEntityBulkEnabledEvent({
+            entity: refType,
+            ids: processedIds,
+            meta
+        }));
+        // Refresh the entity list
+        this.dispatch(AXPRefreshEvent({
+            entity: refType,
+            meta
+        }));
+        // Show error summary if there were any errors
+        if (errors.length > 0) {
+            const errorMessage = errors.map(e => `${e.id}: ${e.error}`).join('\n');
+            console.warn('Some items failed to enable:', errorMessage);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityBulkEnableSuccessAction, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityBulkEnableSuccessAction }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPEntityBulkEnableSuccessAction, decorators: [{
+            type: Injectable
+        }] });
+const AXPBulkEnableEntityWorkflow = {
+    startStepId: 'bulk-enable-entity',
+    steps: {
+        'bulk-enable-entity': {
+            action: 'AXPEntityBulkEnableAction',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("isCanceled") == false' }],
+                    nextStepId: 'show-success-toast',
+                },
+            ],
+        },
+        'show-success-toast': {
+            action: 'AXPToastAction',
+            input: {
+                color: 'success',
+                title: 'workflow.entity-bulk-enabled',
+                content: 'workflow.entity-bulk-enabled-body',
+            },
+            nextSteps: [
+                {
+                    conditions: [],
+                    nextStepId: 'bulk-enable-success',
+                },
+            ],
+        },
+        'bulk-enable-success': {
+            action: 'AXPEntityBulkEnableSuccessAction',
+        },
+    },
+};
+
+class AXPDisablePluginModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPDisablePluginModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.3", ngImport: i0, type: AXPDisablePluginModule, imports: [i1.AXPWorkflowModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPDisablePluginModule, providers: [
+            { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: disablePlugin },
+        ], imports: [AXPWorkflowModule.forChild({
+                actions: {
+                    AXPEntityDisableAction,
+                    AXPEntityDisableSuccessAction,
+                    AXPEntityEnableAction,
+                    AXPEntityEnableSuccessAction,
+                    AXPEntityBulkDisableAction,
+                    AXPEntityBulkDisableSuccessAction,
+                    AXPEntityBulkEnableAction,
+                    AXPEntityBulkEnableSuccessAction,
+                },
+                workflows: {
+                    'disable-entity': AXPDisableEntityWorkflow,
+                    'enable-entity': AXPEnableEntityWorkflow,
+                    'bulk-disable-entity': AXPBulkDisableEntityWorkflow,
+                    'bulk-enable-entity': AXPBulkEnableEntityWorkflow,
+                },
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXPDisablePluginModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPWorkflowModule.forChild({
+                            actions: {
+                                AXPEntityDisableAction,
+                                AXPEntityDisableSuccessAction,
+                                AXPEntityEnableAction,
+                                AXPEntityEnableSuccessAction,
+                                AXPEntityBulkDisableAction,
+                                AXPEntityBulkDisableSuccessAction,
+                                AXPEntityBulkEnableAction,
+                                AXPEntityBulkEnableSuccessAction,
+                            },
+                            workflows: {
+                                'disable-entity': AXPDisableEntityWorkflow,
+                                'enable-entity': AXPEnableEntityWorkflow,
+                                'bulk-disable-entity': AXPBulkDisableEntityWorkflow,
+                                'bulk-enable-entity': AXPBulkEnableEntityWorkflow,
+                            },
+                        }),
+                    ],
+                    providers: [
+                        { provide: AXP_ENTITY_ACTION_PLUGIN, multi: true, useValue: disablePlugin },
+                    ],
+                }]
+        }] });
+
 class AXPComparePopupComponent extends AXBasePageComponent {
     constructor() {
         super(...arguments);
@@ -3510,6 +4415,7 @@ class AXMCommonModule {
             AXPComputedPropertiesModule,
             AXPClonePluginModule,
             AXPArchivePluginModule,
+            AXPDisablePluginModule,
             AXPPrimaryPluginModule,
             AXPCompareModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.3", ngImport: i0, type: AXMCommonModule, providers: [
@@ -3552,6 +4458,7 @@ class AXMCommonModule {
             AXPComputedPropertiesModule,
             AXPClonePluginModule,
             AXPArchivePluginModule,
+            AXPDisablePluginModule,
             AXPPrimaryPluginModule,
             AXPCompareModule] }); }
 }
@@ -3568,6 +4475,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImpor
                         AXPComputedPropertiesModule,
                         AXPClonePluginModule,
                         AXPArchivePluginModule,
+                        AXPDisablePluginModule,
                         AXPPrimaryPluginModule,
                         AXPCompareModule,
                     ],
@@ -3612,5 +4520,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.3", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AXMCommonModule, AXMLockPopupWorkflow, AXMLockPopupWorkflowAction, AXMMenuProvider, AXMSearchCommandProvider, AXMSettingProvider, AXMUnlockConfirmWorkflow, AXMUnlockConfirmWorkflowAction, AXPGlobalSearchModule, AXPGlobalSearchViewModel, AXPVersionHistoryModule, AXPWidgetsList, AXP_GLOBAL_SEARCH_CONFIG_TOKEN, RootConfig };
+export { AXMCommonModule, AXMLockPopupWorkflow, AXMLockPopupWorkflowAction, AXMMenuProvider, AXMSearchCommandProvider, AXMSettingProvider, AXMUnlockConfirmWorkflow, AXMUnlockConfirmWorkflowAction, AXPDisablePluginModule, AXPGlobalSearchModule, AXPGlobalSearchViewModel, AXPVersionHistoryModule, AXPWidgetsList, AXP_GLOBAL_SEARCH_CONFIG_TOKEN, RootConfig, disablePlugin };
 //# sourceMappingURL=acorex-modules-common.mjs.map