@acorex/modules 20.6.0-next.2 → 20.6.0-next.4

package/fesm2022/acorex-modules-workflow-management.mjs

@@ -1,21 +1,106 @@
+import * as i0 from '@angular/core';
+import { inject, Injector, Injectable, runInInjectionContext, NgModule } from '@angular/core';
+import { AXPSessionService, AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
+import { AXPEntityService, ensureListActions, actionExists, AXMEntityCrudServiceImpl, AXP_ENTITY_ACTION_PLUGIN, AXPEntityDefinitionRegistryService, entityMasterDeleteAction, AXP_ENTITY_DEFINITION_LOADER, entityMasterCrudActions, entityMasterRecordActions } from '@acorex/platform/layout/entity';
+import { firstValueFrom } from 'rxjs';
 import { AXMCalendarManagementModule } from '@acorex/modules/calendar-management';
 import { AXPEntityCommandScope, createAllQueryView, AXPEntityQueryType, AXP_MENU_PROVIDER } from '@acorex/platform/common';
-import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
-import * as i0 from '@angular/core';
-import { inject, Injector, runInInjectionContext, Injectable, NgModule } from '@angular/core';
-import { ensureListActions, actionExists, AXMEntityCrudServiceImpl, AXP_ENTITY_ACTION_PLUGIN, AXPEntityDefinitionRegistryService, entityMasterDeleteAction, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
+import { AXPCommandExecutor, provideCommandSetups } from '@acorex/platform/runtime';
 import * as i2 from '@acorex/platform/layout/widget-core';
 import { AXPWidgetGroupEnum, AXP_WIDGETS_LAYOUT_CATEGORY, AXPWidgetCoreModule, AXPWidgetsCatalog } from '@acorex/platform/layout/widget-core';
 import * as i1 from '@acorex/platform/workflow';
-import { AXPWorkflowAction, AXPWorkflowModule } from '@acorex/platform/workflow';
+import { AXPWorkflowAction, AXPWorkflowModule, WorkflowCoordinator } from '@acorex/platform/workflow';
 import { AXTranslationService } from '@acorex/core/translation';
 import { AXPLayoutBuilderService } from '@acorex/platform/layout/builder';
 import { AXP_NAME_PROPERTY, AXP_DATA_PATH_PROPERTY } from '@acorex/platform/layout/widgets';
 import { AXPWorkflowTaskProvider, AXP_WORKFLOW_TASK_PROVIDER } from '@acorex/modules/task-management';
-import { AXPCommandExecutor, provideCommandSetups } from '@acorex/platform/runtime';
+import { AXToastService } from '@acorex/components/toast';
+import { AXPWidgetsList } from '@acorex/modules/common';
+
+const config = {
+    i18n: 'workflow-management',
+    module: 'WorkflowManagement',
+};
+const RootConfig = {
+    config,
+    module: {
+        route: 'workflow-management',
+        name: config.module,
+        title: '@workflow-management:module.title',
+        icon: 'fa-light fa-diagram-project',
+    },
+    entities: {
+        workflowDefinition: {
+            name: 'WorkflowDefinition',
+            source: `${config.module}.WorkflowDefinition`,
+            title: '@workflow-management:workflow-definitions.entities.workflow-definition.title',
+            titlePlural: '@workflow-management:workflow-definitions.entities.workflow-definition.plural',
+            icon: 'fa-light fa-diagram-project',
+        },
+    },
+};
+
+class AXMWorkflowManagementModuleEntityProvider {
+    constructor() {
+        this.injector = inject(Injector);
+    }
+    preload() {
+        const module = RootConfig.module.name;
+        return Array.from(Object.values(RootConfig.entities)).map((entity) => ({
+            module: module,
+            entity: entity.name,
+        }));
+    }
+    async get(moduleName, entityName) {
+        if (moduleName === RootConfig.module.name) {
+            switch (entityName) {
+                case RootConfig.entities.workflowDefinition.name:
+                    return (await Promise.resolve().then(function () { return workflowDefinition_entity; })).factory(this.injector);
+            }
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMWorkflowManagementModuleEntityProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMWorkflowManagementModuleEntityProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMWorkflowManagementModuleEntityProvider, decorators: [{
+            type: Injectable
+        }] });
+
+const AXPWorkflowManagementMenuKeys = {
+    Root: 'workflow-management:menu',
+    WorkflowDefinitions: 'workflow-management:workflow-definitions',
+};
 
 class AXMMenuProvider {
-    async provide(context) { }
+    constructor() {
+        this.entityService = inject(AXPEntityService);
+        this.sessionService = inject(AXPSessionService);
+    }
+    async provide(context) {
+        const isAuthorized = await firstValueFrom(this.sessionService.isAuthorized$);
+        if (!isAuthorized) {
+            return;
+        }
+        const module = RootConfig.module;
+        context.addItems([
+            {
+                name: AXPWorkflowManagementMenuKeys.Root,
+                priority: 9500,
+                text: '@workflow-management:module.menus.root.title',
+                icon: module.icon,
+                children: [
+                    {
+                        name: AXPWorkflowManagementMenuKeys.WorkflowDefinitions,
+                        text: '@workflow-management:workflow-definitions.menus.workflow-definitions.title',
+                        path: this.entityService.createPath(module.name, RootConfig.entities.workflowDefinition.name),
+                        priority: 10,
+                        icon: RootConfig.entities.workflowDefinition.icon,
+                    },
+                ],
+            },
+        ]);
+    }
 }
 
 const signPlugin = {
@@ -970,10 +1055,481 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImpo
                 }]
         }] });
 
+class AXMWorkflowManagementWorkflowDefinitionEntityService extends AXMEntityCrudServiceImpl {
+}
+class AXMWorkflowManagementWorkflowDefinitionEntityServiceImpl extends AXMWorkflowManagementWorkflowDefinitionEntityService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.workflowDefinition.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMWorkflowManagementWorkflowDefinitionEntityServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMWorkflowManagementWorkflowDefinitionEntityServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMWorkflowManagementWorkflowDefinitionEntityServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+class AXMWorkflowManagementWorkflowDefinitionEntityModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMWorkflowManagementWorkflowDefinitionEntityModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.10", ngImport: i0, type: AXMWorkflowManagementWorkflowDefinitionEntityModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMWorkflowManagementWorkflowDefinitionEntityModule, providers: [
+            {
+                provide: AXMWorkflowManagementWorkflowDefinitionEntityService,
+                useClass: AXMWorkflowManagementWorkflowDefinitionEntityServiceImpl,
+            },
+        ] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMWorkflowManagementWorkflowDefinitionEntityModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMWorkflowManagementWorkflowDefinitionEntityService,
+                            useClass: AXMWorkflowManagementWorkflowDefinitionEntityServiceImpl,
+                        },
+                    ],
+                }]
+        }] });
+
+//#endregion
+/**
+ * Execute Workflow Command
+ *
+ * Starts and manages workflow execution from entity list.
+ * Handles the complete workflow lifecycle including frontend/backend activities.
+ */
+class ExecuteWorkflowCommand {
+    constructor() {
+        //#region ----   Services   ----
+        this.workflowCoordinator = inject(WorkflowCoordinator);
+        this.toastService = inject(AXToastService);
+    }
+    //#endregion
+    //#region ----   Command Implementation   ----
+    async execute(input) {
+        try {
+            console.log(`[ExecuteWorkflowCommand] Starting workflow: ${input.definitionId}`);
+            // Start workflow execution
+            const result = await this.workflowCoordinator.startWorkflow(input.definitionId, input.input || {});
+            if (!result.success) {
+                this.toastService.show({
+                    color: 'danger',
+                    title: 'Workflow Execution Failed',
+                    content: result.error || 'Unknown error',
+                    closeButton: true,
+                    timeOut: 5000,
+                });
+                return {
+                    executionId: result.executionId || '',
+                    output: null,
+                    success: false,
+                };
+            }
+            // Handle workflow execution loop
+            let currentResult = result;
+            while (currentResult.nextTask) {
+                const task = currentResult.nextTask;
+                console.log(`[ExecuteWorkflowCommand] Executing frontend task: ${task.activityType}`);
+                // Execute frontend task
+                const { output, outcome } = await this.workflowCoordinator.executeTask(task);
+                // Complete task and get next
+                currentResult = await this.workflowCoordinator.completeTask(currentResult.executionId, task, outcome, output);
+                if (!currentResult.success) {
+                    this.toastService.show({
+                        color: 'danger',
+                        title: 'Workflow Execution Failed',
+                        content: currentResult.error || 'Unknown error',
+                        closeButton: true,
+                        timeOut: 5000,
+                    });
+                    return {
+                        executionId: currentResult.executionId || '',
+                        output: null,
+                        success: false,
+                    };
+                }
+            }
+            // Workflow completed successfully
+            console.log(`[ExecuteWorkflowCommand] Workflow completed:`, currentResult.state?.output);
+            this.toastService.show({
+                color: 'success',
+                title: 'Workflow Completed',
+                content: 'Workflow executed successfully',
+                closeButton: true,
+                timeOut: 3000,
+            });
+            return {
+                executionId: currentResult.executionId,
+                output: currentResult.state?.output,
+                success: true,
+            };
+        }
+        catch (error) {
+            console.error(`[ExecuteWorkflowCommand] Error:`, error);
+            this.toastService.show({
+                color: 'danger',
+                title: 'Workflow Execution Error',
+                content: error.message || 'Unknown error',
+                closeButton: true,
+                timeOut: 5000,
+            });
+            return {
+                executionId: '',
+                output: null,
+                success: false,
+            };
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: ExecuteWorkflowCommand, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: ExecuteWorkflowCommand }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: ExecuteWorkflowCommand, decorators: [{
+            type: Injectable
+        }] });
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ExecuteWorkflowCommand: ExecuteWorkflowCommand
+});
+
+async function factory(injector) {
+    const dataService = injector.get(AXMWorkflowManagementWorkflowDefinitionEntityService);
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.workflowDefinition.name,
+        title: RootConfig.entities.workflowDefinition.title,
+        icon: RootConfig.entities.workflowDefinition.icon,
+        formats: {
+            individual: RootConfig.entities.workflowDefinition.title,
+            plural: RootConfig.entities.workflowDefinition.titlePlural,
+            displayName: '{{ name }}',
+            searchResult: {
+                title: '{{ name }}',
+                description: '{{ description }}',
+            },
+        },
+        plugins: [
+            { name: 'history' },
+            { name: 'lock' },
+            { name: 'archive' },
+        ],
+        groups: [
+            {
+                id: 'basicInfo',
+                title: '@workflow-management:workflow-definitions.entities.workflow-definition.groups.basic-info',
+            },
+            {
+                id: 'configuration',
+                title: '@workflow-management:workflow-definitions.entities.workflow-definition.groups.configuration',
+            },
+            {
+                id: 'metadata',
+                title: '@workflow-management:workflow-definitions.entities.workflow-definition.groups.metadata',
+            },
+        ],
+        properties: [
+            {
+                name: 'id',
+                title: 'ID',
+                groupId: 'metadata',
+                schema: {
+                    dataType: 'uuid',
+                    hidden: true,
+                    nullable: false,
+                    readonly: true,
+                    unique: { enabled: true },
+                },
+            },
+            {
+                name: 'definitionId',
+                title: '@workflow-management:workflow-definitions.entities.workflow-definition.fields.definition-id.title',
+                groupId: 'basicInfo',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                        options: {
+                            placeholder: '@workflow-management:workflow-definitions.entities.workflow-definition.fields.definition-id.placeholder',
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'name',
+                title: '@workflow-management:workflow-definitions.entities.workflow-definition.fields.name.title',
+                groupId: 'basicInfo',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                        options: {
+                            placeholder: '@workflow-management:workflow-definitions.entities.workflow-definition.fields.name.placeholder',
+                        },
+                    },
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'description',
+                title: '@workflow-management:workflow-definitions.entities.workflow-definition.fields.description.title',
+                groupId: 'basicInfo',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.LargeTextBox,
+                        options: {
+                            rows: 3,
+                            placeholder: '@workflow-management:workflow-definitions.entities.workflow-definition.fields.description.placeholder',
+                        },
+                    },
+                },
+            },
+            {
+                name: 'version',
+                title: '@workflow-management:workflow-definitions.entities.workflow-definition.fields.version.title',
+                groupId: 'metadata',
+                schema: {
+                    dataType: 'number',
+                    interface: {
+                        type: AXPWidgetsCatalog.number,
+                    },
+                    readonly: true,
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true } },
+                },
+            },
+            {
+                name: 'isLatest',
+                title: '@workflow-management:workflow-definitions.entities.workflow-definition.fields.is-latest.title',
+                groupId: 'metadata',
+                schema: {
+                    dataType: 'boolean',
+                    interface: {
+                        type: AXPWidgetsCatalog.toggle,
+                    },
+                    readonly: true,
+                },
+                options: {
+                    filter: { inline: { enabled: true } },
+                },
+            },
+            {
+                name: 'isPublished',
+                title: '@workflow-management:workflow-definitions.entities.workflow-definition.fields.is-published.title',
+                groupId: 'configuration',
+                schema: {
+                    dataType: 'boolean',
+                    interface: {
+                        type: AXPWidgetsCatalog.toggle,
+                    },
+                },
+                options: {
+                    filter: { inline: { enabled: true } },
+                },
+            },
+            {
+                name: 'isReadonly',
+                title: '@workflow-management:workflow-definitions.entities.workflow-definition.fields.is-readonly.title',
+                groupId: 'configuration',
+                schema: {
+                    dataType: 'boolean',
+                    interface: {
+                        type: AXPWidgetsCatalog.toggle,
+                    },
+                },
+            },
+            {
+                name: 'isSystem',
+                title: '@workflow-management:workflow-definitions.entities.workflow-definition.fields.is-system.title',
+                groupId: 'configuration',
+                schema: {
+                    dataType: 'boolean',
+                    interface: {
+                        type: AXPWidgetsCatalog.toggle,
+                    },
+                    readonly: true,
+                },
+            },
+            {
+                name: 'createdAt',
+                title: '@workflow-management:workflow-definitions.entities.workflow-definition.fields.created-at.title',
+                groupId: 'metadata',
+                schema: {
+                    dataType: 'date',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                    },
+                    readonly: true,
+                },
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true } },
+                },
+            },
+        ],
+        columns: [
+            {
+                name: 'name',
+                title: '@workflow-management:workflow-definitions.entities.workflow-definition.fields.name.title',
+                showAs: { type: AXPWidgetsCatalog.text },
+            },
+            {
+                name: 'definitionId',
+                title: '@workflow-management:workflow-definitions.entities.workflow-definition.fields.definition-id.title',
+                showAs: { type: AXPWidgetsCatalog.text },
+            },
+            {
+                name: 'version',
+                title: '@workflow-management:workflow-definitions.entities.workflow-definition.fields.version.title',
+                showAs: { type: AXPWidgetsCatalog.number },
+                options: { width: '100px' },
+            },
+            {
+                name: 'isLatest',
+                title: '@workflow-management:workflow-definitions.entities.workflow-definition.fields.is-latest.title',
+                showAs: { type: AXPWidgetsCatalog.toggle, options: { trueText: 'Latest', falseText: '-' } },
+                options: { width: '100px' },
+            },
+            {
+                name: 'isPublished',
+                title: '@workflow-management:workflow-definitions.entities.workflow-definition.fields.is-published.title',
+                showAs: { type: AXPWidgetsCatalog.toggle },
+                options: { width: '120px' },
+            },
+            {
+                name: 'createdAt',
+                title: '@workflow-management:workflow-definitions.entities.workflow-definition.fields.created-at.title',
+                showAs: { type: AXPWidgetsCatalog.dateTime },
+                options: { width: '180px' },
+            },
+        ],
+        commands: {
+            create: {
+                execute: async (data) => ({ id: await dataService.insertOne(data) }),
+            },
+            delete: {
+                execute: async (id) => await dataService.deleteOne(id),
+            },
+            update: {
+                execute: async (data) => await dataService.updateOne(data.id, data),
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    const item = await dataService.getOne(id);
+                    return item;
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await dataService.query(e);
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [{ id: 'basicInfo' }, { id: 'configuration' }],
+                    properties: [
+                        { name: 'definitionId', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12 } } } },
+                        { name: 'isPublished', layout: { positions: { lg: { colSpan: 4 } } } },
+                        { name: 'isReadonly', layout: { positions: { lg: { colSpan: 4 } } } },
+                    ],
+                },
+                update: {
+                    sections: [{ id: 'basicInfo' }, { id: 'configuration' }],
+                    properties: [
+                        { name: 'definitionId', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12 } } } },
+                        { name: 'isPublished', layout: { positions: { lg: { colSpan: 4 } } } },
+                        { name: 'isReadonly', layout: { positions: { lg: { colSpan: 4 } } } },
+                    ],
+                },
+                single: {
+                    title: '{{ name }}',
+                    sections: [
+                        { id: 'basicInfo', order: 1, layout: { positions: { lg: { colSpan: 12 } } } },
+                        { id: 'configuration', order: 2, layout: { positions: { lg: { colSpan: 6 } } } },
+                        { id: 'metadata', order: 3, layout: { positions: { lg: { colSpan: 6 } } } },
+                    ],
+                    properties: [
+                        { name: 'definitionId', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'name', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'description', layout: { positions: { lg: { colSpan: 12 } } } },
+                        { name: 'version', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'isLatest', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'isPublished', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'isReadonly', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'isSystem', layout: { positions: { lg: { colSpan: 6 } } } },
+                        { name: 'createdAt', layout: { positions: { lg: { colSpan: 6 } } } },
+                    ],
+                    actions: [...entityMasterRecordActions()],
+                },
+                list: {
+                    actions: [
+                        ...entityMasterCrudActions(),
+                        {
+                            title: '@workflow-management:workflow-definitions.actions.execute.title',
+                            name: 'execute-workflow',
+                            command: {
+                                name: 'WorkflowManagement.WorkflowDefinition:Execute',
+                                options: {
+                                    definitionId: '{{ context.eval("definitionId") }}',
+                                    input: {},
+                                },
+                            },
+                            icon: 'fa-light fa-play',
+                            color: 'success',
+                            priority: 'primary',
+                            type: 'execute',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [createAllQueryView({ sorts: [{ name: 'createdAt', dir: 'desc' }] })],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+var workflowDefinition_entity = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    factory: factory
+});
+
 class AXMWorkflowManagementModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMWorkflowManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.10", ngImport: i0, type: AXMWorkflowManagementModule, imports: [AXMCalendarManagementModule, AXMSignPluginModule, AXPDistributionPluginModule] }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.10", ngImport: i0, type: AXMWorkflowManagementModule, imports: [AXMCalendarManagementModule,
+            AXMSignPluginModule,
+            AXPDistributionPluginModule,
+            AXMWorkflowManagementWorkflowDefinitionEntityModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMWorkflowManagementModule, providers: [
+            provideCommandSetups([
+                {
+                    key: 'WorkflowManagement.WorkflowDefinition:Execute',
+                    command: () => Promise.resolve().then(function () { return index; }).then((c) => c.ExecuteWorkflowCommand),
+                },
+            ]),
             {
                 provide: AXP_MENU_PROVIDER,
                 useClass: AXMMenuProvider,
@@ -987,13 +1543,32 @@ class AXMWorkflowManagementModule {
                 },
                 multi: true,
             },
-        ], imports: [AXMCalendarManagementModule, AXMSignPluginModule, AXPDistributionPluginModule] }); }
+            {
+                provide: AXP_ENTITY_DEFINITION_LOADER,
+                useClass: AXMWorkflowManagementModuleEntityProvider,
+                multi: true,
+            },
+        ], imports: [AXMCalendarManagementModule,
+            AXMSignPluginModule,
+            AXPDistributionPluginModule,
+            AXMWorkflowManagementWorkflowDefinitionEntityModule] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImport: i0, type: AXMWorkflowManagementModule, decorators: [{
             type: NgModule,
             args: [{
-                    imports: [AXMCalendarManagementModule, AXMSignPluginModule, AXPDistributionPluginModule],
+                    imports: [
+                        AXMCalendarManagementModule,
+                        AXMSignPluginModule,
+                        AXPDistributionPluginModule,
+                        AXMWorkflowManagementWorkflowDefinitionEntityModule,
+                    ],
                     providers: [
+                        provideCommandSetups([
+                            {
+                                key: 'WorkflowManagement.WorkflowDefinition:Execute',
+                                command: () => Promise.resolve().then(function () { return index; }).then((c) => c.ExecuteWorkflowCommand),
+                            },
+                        ]),
                         {
                             provide: AXP_MENU_PROVIDER,
                             useClass: AXMMenuProvider,
@@ -1007,6 +1582,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImpo
                             },
                             multi: true,
                         },
+                        {
+                            provide: AXP_ENTITY_DEFINITION_LOADER,
+                            useClass: AXMWorkflowManagementModuleEntityProvider,
+                            multi: true,
+                        },
                     ],
                 }]
         }] });
@@ -1015,5 +1595,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.10", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { AXMCommonCreateDistributionRecordsAction, AXMCommonDistributionPopupAction, AXMCommonDistributionWorkflow, AXMMenuProvider, AXMSignPluginModule, AXMSignPopupAction, AXMSignWorkflow, AXMWorkflowManagementModule, AXPDistributionPluginModule, distributionPlugin, signPlugin };
+export { AXMCommonCreateDistributionRecordsAction, AXMCommonDistributionPopupAction, AXMCommonDistributionWorkflow, AXMMenuProvider, AXMSignPluginModule, AXMSignPopupAction, AXMSignWorkflow, AXMWorkflowManagementModule, AXMWorkflowManagementModuleEntityProvider, AXMWorkflowManagementWorkflowDefinitionEntityModule, AXMWorkflowManagementWorkflowDefinitionEntityService, AXMWorkflowManagementWorkflowDefinitionEntityServiceImpl, AXPDistributionPluginModule, ExecuteWorkflowCommand, RootConfig, distributionPlugin, signPlugin, factory as workflowDefinitionEntityFactory };
 //# sourceMappingURL=acorex-modules-workflow-management.mjs.map