@acorex/modules 20.0.5 → 20.0.7

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

@@ -0,0 +1,976 @@
+import { AXPSessionService, AXPAuthGuard } from '@acorex/platform/auth';
+import { AXP_REPORT_DEFINITION_PROVIDER, AXP_REPORT_CATEGORY_PROVIDER, createAllQueryView, AXPEntityCommandScope, AXPEntityQueryType, AXPLockService, AXP_MENU_PROVIDER } from '@acorex/platform/common';
+import { AXPDomainModule, provideEntity } from '@acorex/platform/domain';
+import { AXPQueryService, provideCommandSetups } from '@acorex/platform/runtime';
+import { AXPRootLayoutComponent } from '@acorex/platform/themes/default';
+import * as i0 from '@angular/core';
+import { inject, Injectable, NgModule } from '@angular/core';
+import { ROUTES } from '@angular/router';
+import { AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER } from '@acorex/platform/core';
+import * as i1 from '@acorex/platform/workflow';
+import { AXPWorkflowAction, AXPWorkflowModule } from '@acorex/platform/workflow';
+import { AXPWidgetsCatalog } from '@acorex/platform/layout/builder';
+import { AXMEntityCrudServiceImpl } from '@acorex/platform/layout/entity';
+import { AXTranslationService } from '@acorex/core/translation';
+import { AXDataSource } from '@acorex/cdk/common';
+import { AXMDataSourceService } from '@acorex/modules/platform-management';
+import { AXPopupService } from '@acorex/components/popup';
+
+const config = {
+    i18n: 'report-management',
+    module: 'ReportManagement'
+};
+const RootConfig = {
+    config,
+    module: {
+        route: 'report-management',
+        name: config.module,
+        title: `@${config.i18n}.module-name`,
+        icon: 'fa-light fa-chart-bar'
+    },
+    entities: {
+        dataSet: {
+            name: 'DataSet',
+            title: `t("dataSet", { scope: "${config.i18n}" })`,
+            titlePlural: `t("dataSetPlural", { scope: "${config.i18n}" })`,
+            icon: 'fa-light fa-default',
+        },
+        category: {
+            name: 'Category',
+            fullName: `${config.module}.Category`,
+            title: `@${config.i18n}.entities.category.title`,
+            titlePlural: `@${config.i18n}.entities.category.title-plural`,
+            icon: 'fa-light fa-folder'
+        },
+        report: {
+            name: 'Report',
+            fullName: `${config.module}.Report`,
+            title: `@${config.i18n}.entities.report.title`,
+            //titlePlural: `@${config.i18n}.entities.report.title-plural`,
+            titlePlural: `t("entities.report.title-plural",{scope:"${config.i18n}"})`,
+            icon: 'fa-light fa-file-chart-pie'
+        }
+    },
+};
+
+class AXMReportDefinitionProvider {
+    constructor() {
+        this.queryService = inject(AXPQueryService);
+        this.entityName = `${RootConfig.module.name}.${RootConfig.entities.report.name}`;
+    }
+    async getList(categoryId) {
+        const result = (await this.queryService.fetch(`${this.entityName}:GetByCategory`, { categoryId }))?.items;
+        return result ?? [];
+    }
+    async getById(id) {
+        const result = await this.queryService.fetch(`${this.entityName}:GetById`, id);
+        return result ?? undefined;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXMReportDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXMReportDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXMReportDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+const AXM_REPORT_DEFINITION_PROVIDER = {
+    provide: AXP_REPORT_DEFINITION_PROVIDER,
+    useClass: AXMReportDefinitionProvider,
+    multi: true,
+};
+// ---  Category Provider ---
+class AXMReportCategoryProvider {
+    constructor() {
+        this.queryService = inject(AXPQueryService);
+        this.entityName = `${RootConfig.module.name}.${RootConfig.entities.category.name}`;
+    }
+    async getList(parentId) {
+        let result = [];
+        if (parentId) {
+            result = (await this.queryService.fetch(`${this.entityName}:GetChildren`, { parentId }))?.items ?? [];
+        }
+        else {
+            result = (await this.queryService.fetch(`${this.entityName}:GetRoots`, {}))?.items ?? [];
+        }
+        return result ?? [];
+    }
+    async getById(id) {
+        return this.getList().then(cats => cats.find(cat => cat.id === id));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXMReportCategoryProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXMReportCategoryProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXMReportCategoryProvider, decorators: [{
+            type: Injectable
+        }] });
+const AXM_REPORT_CATEGORY_PROVIDER = {
+    provide: AXP_REPORT_CATEGORY_PROVIDER,
+    useClass: AXMReportCategoryProvider,
+    multi: true,
+};
+
+class AXMMenuProvider {
+    constructor() {
+        this.sessionService = inject(AXPSessionService);
+    }
+    async provide(context) {
+        const module = RootConfig.module;
+        context.addItems([
+            {
+                text: RootConfig.entities.report.titlePlural,
+                path: `${this.sessionService.application?.name}/${module.route}/reports`,
+                icon: RootConfig.entities.report.icon,
+                priority: 9001,
+            },
+        ]);
+    }
+}
+
+class AXMDataSetService extends AXMEntityCrudServiceImpl {
+}
+class AXMDataSetServiceImpl extends AXMDataSetService {
+    constructor() {
+        super(`${RootConfig.module.name}.${RootConfig.entities.dataSet.name}`);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXMDataSetServiceImpl, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXMDataSetServiceImpl }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXMDataSetServiceImpl, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+
+//#region ----   DataSet Filter Widget   ----
+const AXM_DATASET_FILTER_WIDGET = [
+    {
+        type: 'block-layout',
+        mode: 'view',
+        children: [
+            {
+                type: 'grid-item-layout',
+                mode: 'view',
+                options: { colSpan: 2 },
+                children: [
+                    {
+                        type: 'checkbox-editor',
+                        mode: 'edit',
+                        path: 'enabled',
+                        defaultValue: true,
+                        options: {
+                            label: 'Enable',
+                            tooltip: 'Enable or disable this filter',
+                            disabled: '{{ context.eval("isRequired") }}',
+                        },
+                    },
+                ],
+            },
+            {
+                type: 'grid-item-layout',
+                mode: 'view',
+                options: { colSpan: 3 },
+                children: [
+                    {
+                        type: 'text-editor',
+                        mode: 'view',
+                        path: 'columnName',
+                    },
+                ],
+            },
+            {
+                type: 'grid-item-layout',
+                mode: 'view',
+                options: { colSpan: 7 },
+                children: [
+                    {
+                        type: 'string-filter',
+                        mode: 'edit',
+                        path: 'defaultValue',
+                        options: {
+                            placeholder: '{{ (context.eval(">enabled") ?? true) ? "Enter filter value" : "Filter is disabled" }}  ',
+                            readonly: '{{ !context.eval(">enabled") }}',
+                        },
+                    },
+                ],
+            },
+        ],
+        // options:{
+        //   "spacing":{"margin":"0px","padding":"25px 7px 27px"}
+        // }
+    },
+];
+//#endregion
+
+//#region ----   DataSet Filter Widget   ----
+const AXM_DATASET_COLUMN_WIDGET = [
+    {
+        type: 'grid-row-layout',
+        mode: 'view',
+        children: [
+            {
+                type: 'grid-item-layout',
+                mode: 'view',
+                options: { colSpan: 2 },
+                children: [
+                    {
+                        type: 'checkbox-editor',
+                        mode: 'edit',
+                        path: 'enabled',
+                        options: {
+                            label: 'Enable',
+                            tooltip: 'Enable or disable this filter',
+                            disabled: '{{ context.eval("isRequired") }}',
+                        },
+                    },
+                ],
+            },
+            {
+                type: 'grid-item-layout',
+                mode: 'view',
+                options: { colSpan: 3 },
+                children: [
+                    {
+                        type: 'text-editor',
+                        mode: 'view',
+                        path: 'title',
+                        options: {
+                        //readonly:   '{{ !context.eval(">enabled") }}',
+                        },
+                    },
+                ],
+            }
+        ],
+    },
+];
+//#endregion
+
+//#region ----   DataSet Filter Widget   ----
+const AXM_DATASET_SORT_WIDGET = [
+    {
+        type: 'grid-item-layout',
+        mode: 'view',
+        options: { colSpan: 3 },
+        children: [
+            {
+                type: 'select-editor',
+                mode: 'edit',
+                path: 'enabled',
+                options: {
+                    dataSource: [
+                        {
+                            value: 'asc',
+                            text: 'Ascendent'
+                        },
+                        {
+                            value: 'desc',
+                            text: 'Desiccate'
+                        },
+                        {
+                            value: 'none',
+                            text: 'None'
+                        },
+                    ],
+                    textField: 'text',
+                    valueField: 'value',
+                },
+            },
+        ],
+    },
+];
+//#endregion
+
+async function dataSetFactory(injector) {
+    const dataService = injector.get(AXMDataSetService);
+    const i18n = RootConfig.config.i18n;
+    const translationService = injector.get(AXTranslationService);
+    const dataSourceService = injector.get(AXMDataSourceService);
+    const entityDef = {
+        module: RootConfig.module.name,
+        name: RootConfig.entities.dataSet.name,
+        source: '',
+        title: RootConfig.entities.dataSet.title,
+        formats: {
+            individual: RootConfig.entities.dataSet.title,
+            plural: RootConfig.entities.dataSet.titlePlural,
+            searchResult: {
+                title: '{{ title }}',
+                description: RootConfig.module.title,
+            },
+        },
+        relatedEntities: [],
+        groups: [
+            {
+                id: 'dataSet',
+                title: RootConfig.entities.dataSet.title,
+            },
+            {
+                id: 'filters',
+                title: `t("advance", { scope: "${i18n}" })`,
+            },
+        ],
+        properties: [
+            {
+                name: 'name',
+                title: `t("name", { scope: "common" })`,
+                groupId: 'dataSet',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: false,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'title',
+                title: `t("title", { scope: "common" })`,
+                groupId: 'dataSet',
+                options: {
+                    sort: {
+                        enabled: true,
+                    },
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: false,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'categoryIds',
+                title: 't("category", { scope: "common" })',
+                groupId: 'dataSet',
+                schema: {
+                    defaultValue: '{{ [context.eval("categoryId")] }}',
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.lookup,
+                        options: {
+                            entity: `${RootConfig.module.name}.${RootConfig.entities.category.name}`,
+                            multiple: true,
+                            expose: [
+                                { source: 'id', target: 'categories.{id}' },
+                                { source: 'title', target: 'categories.{title}' },
+                            ],
+                        },
+                    },
+                },
+                validations: [
+                    {
+                        rule: 'required',
+                    },
+                ],
+            },
+            {
+                name: 'dataSource',
+                title: `t("dataSource", { scope: "${i18n}" })`,
+                groupId: 'dataSet',
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.select,
+                        options: {
+                            valueField: 'name',
+                            textField: 'title',
+                            dataSource: new AXDataSource({
+                                load: async () => {
+                                    const items = await dataSourceService.query({
+                                        skip: 0, take: 10000
+                                    });
+                                    const translated = await Promise.all(items.items.map(async (item) => ({
+                                        ...item,
+                                        title: await translationService.translateAsync(item.title),
+                                    })));
+                                    return { total: translated.length, items: translated };
+                                },
+                                pageSize: 1000,
+                            }),
+                            multiple: false,
+                        },
+                        triggers: [
+                            {
+                                event: "{{ events.context('dataSource') }}",
+                                action: `{{ var ds = context.eval('dataSource'); var list = []; Array.isArray(ds.filters) ? (function(){ for(var i=0;i<ds.filters.length;i++){ var item = ds.filters[i]; !item.isSystemFilter ? (function(){ var fl = item.filter; var column = (ds.columns || []).find(function(c){return c.name === fl.columnName;}) || {}; var widgetType = (function(){ var t = column.type || 'string'; t = (typeof t === 'object' && t !== null && 'name' in t) ? t.name : t; return t === 'text-editor' || t === 'large-text-editor' || t === 'string' ? 'string-filter' : t === 'number-editor' || t === 'number' ? 'number-filter' : t === 'date-time-editor' || t === 'datetime' || t === 'date' ? 'datetime-filter' : t === 'select-editor' || t === 'select' ? 'select-filter' : t === 'checkbox-editor' || t === 'toggle-editor' || t === 'boolean' ? 'boolean-filter' : t === 'color-editor' ? 'color-filter' : 'string-filter'; })(); var copy = { columnName: fl.columnName, isRequired: false, enabled: true, filter: { columnName: fl.columnName, value: fl.value }, widgetType: widgetType }; list.push(copy); })() : null; } })() : null; context.set('filters', list); }}`,
+                            },
+                        ],
+                    },
+                },
+                validations: [
+                    { rule: 'required' },
+                ],
+            },
+            {
+                name: 'filters',
+                title: `t("filters", { scope: "${i18n}" })`,
+                groupId: 'filters',
+                schema: {
+                    defaultValue: [],
+                    dataType: 'object',
+                    interface: {
+                        type: AXPWidgetsCatalog.repeaterLayout,
+                        path: 'filters',
+                        options: {
+                            hasControls: false,
+                            isDraggable: true
+                        },
+                        children: AXM_DATASET_FILTER_WIDGET,
+                    },
+                },
+            },
+            {
+                name: 'columns',
+                title: `t("columns", { scope: "${i18n}" })`,
+                groupId: 'filters',
+                schema: {
+                    defaultValue: [],
+                    dataType: 'object',
+                    interface: {
+                        type: AXPWidgetsCatalog.repeaterLayout,
+                        options: {
+                            hasControls: false,
+                            isDraggable: true
+                        },
+                        children: AXM_DATASET_COLUMN_WIDGET,
+                        triggers: [
+                            {
+                                event: "{{ events.context('dataSource') }}",
+                                action: `{{ context.set('columns', context.eval('dataSource').columns); }}`,
+                            },
+                        ],
+                    },
+                },
+            },
+            {
+                name: 'sorts',
+                title: `t("sorts", { scope: "${i18n}" })`,
+                groupId: 'filters',
+                schema: {
+                    defaultValue: [],
+                    dataType: 'object',
+                    interface: {
+                        type: AXPWidgetsCatalog.repeaterLayout,
+                        options: {
+                            hasControls: false,
+                            isDraggable: true
+                        },
+                        children: AXM_DATASET_SORT_WIDGET,
+                        // triggers: [
+                        //   {
+                        //     event: "{{ events.context('dataSource') }}",
+                        //     action: `{{ context.set('sorts', context.eval('dataSource').columns); }}`,
+                        //   },
+                        // ],
+                    },
+                },
+            },
+        ],
+        columns: [{ name: 'name' }, { name: 'title' }, { name: 'dataSource' }],
+        commands: {
+            create: {
+                execute: async (data) => {
+                    console.log(data);
+                    const res = await dataService.insertOne(data);
+                    return { id: res };
+                },
+            },
+            delete: {
+                execute: async (id) => {
+                    return await dataService.deleteOne(id);
+                },
+            },
+            update: {
+                execute: async (data) => {
+                    return await dataService.updateOne(data.id, data);
+                },
+            },
+        },
+        queries: {
+            byKey: {
+                execute: async (id) => {
+                    return await dataService.getOne(id);
+                },
+                type: AXPEntityQueryType.Single,
+            },
+            list: {
+                execute: async (e) => {
+                    return await dataService.query({ skip: e.skip, take: e.take, filter: e.filter });
+                },
+                type: AXPEntityQueryType.List,
+            },
+        },
+        interfaces: {
+            master: {
+                create: {
+                    sections: [
+                        {
+                            id: 'dataSet',
+                        },
+                        {
+                            id: 'filters',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'dataSource',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'filters',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 5,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'columns',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 5,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'sorts',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 6,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                update: {
+                    sections: [
+                        {
+                            id: 'dataSet',
+                        },
+                        {
+                            id: 'filters',
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'dataSource',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'filters',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 5,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+                single: {
+                    title: '{{title}}',
+                    sections: [
+                        {
+                            id: 'dataSet',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    properties: [
+                        {
+                            name: 'dataSource',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 3,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'name',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 1,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'title',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 2,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'categoryIds',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 6,
+                                        order: 4,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            name: 'filters',
+                            layout: {
+                                positions: {
+                                    lg: {
+                                        colSpan: 12,
+                                        order: 5,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                    actions: [],
+                },
+                list: {
+                    actions: [
+                        {
+                            title: `t("create", { scope: "common" })`,
+                            command: 'create-entity',
+                            priority: 'primary',
+                            type: 'create',
+                            scope: AXPEntityCommandScope.TypeLevel,
+                        },
+                        {
+                            title: 't("deleteItems", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'primary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Selected,
+                        },
+                        {
+                            title: 't("detail", { scope: "common" })',
+                            command: 'open-entity',
+                            priority: 'secondary',
+                            type: 'view',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                        {
+                            title: 't("delete", { scope: "common" })',
+                            command: 'delete-entity',
+                            priority: 'secondary',
+                            type: 'delete',
+                            scope: AXPEntityCommandScope.Individual,
+                        },
+                    ],
+                    views: [
+                        createAllQueryView({
+                            sorts: [{ name: 'name', dir: 'asc' }]
+                        }),
+                    ],
+                },
+            },
+        },
+    };
+    return entityDef;
+}
+
+class AXMColumnEvaluatorScopeProvider {
+    constructor() {
+        this.lockService = inject(AXPLockService);
+    }
+    async provide(context) {
+        context.addScope('dataSource', {
+            getColumn: async (columnName, columns) => {
+                const column = columns.find(c => c.name === columnName);
+                return column;
+            }
+        });
+    }
+}
+
+class AXMReportCreateRootWorkflowAction extends AXPWorkflowAction {
+    constructor() {
+        super(...arguments);
+        this.popupService = inject(AXPopupService);
+        this.translationService = inject(AXTranslationService);
+    }
+    async execute(context) {
+        //  const refId = context.getVariable<string>('options.refId');
+        const comp = await import('./acorex-modules-report-management-report-create-root.component-LrE6TkIp.mjs').then(m => m.AXPReportCreateRootComponent);
+        this.popupService.open(comp, await this.translationService.translateAsync('report.create.title', { scope: 'report-management' }));
+    }
+}
+const AXMReportCreateWorkflow = {
+    startStepId: 'report-create-root',
+    steps: {
+        'report-create-root': {
+            action: 'AXMReportCreateRootWorkflowAction',
+            nextSteps: [
+                {
+                    conditions: [{ type: 'SINGLE', expression: 'context.getOutput("unlocked") == true' }],
+                    nextStepId: 'successToast',
+                },
+            ],
+        },
+        successToast: {
+            id: 'successToast',
+            action: 'AXPToastAction',
+            input: {
+                color: 'success',
+                title: 'workflow.entity-modified-title',
+                content: 'workflow.entity-modified-body',
+            },
+            nextSteps: [
+                {
+                    conditions: [],
+                    nextStepId: 'modifyConfirmed',
+                },
+            ],
+        },
+        // modifyConfirmed: {
+        //   id: 'modifyConfirmed',
+        //   action: 'AXPEntityModifyConfirmedAction',
+        // },
+    },
+};
+
+function routesFacory() {
+    let routes = [
+        {
+            path: `:app/${RootConfig.module.route}/reports`,
+            canActivate: [AXPAuthGuard],
+            loadComponent: () => {
+                return AXPRootLayoutComponent;
+            },
+            children: [
+                {
+                    path: '**',
+                    loadComponent: () => import('./acorex-modules-report-management-report-runner-root-page.component-BntIoMfN.mjs').then((c) => c.AXMReportRunnerRootPageComponent),
+                    data: { reuse: true },
+                },
+            ],
+        },
+    ];
+    return routes;
+}
+class AXMReportManagementModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXMReportManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.0.6", ngImport: i0, type: AXMReportManagementModule, imports: [AXPDomainModule, i1.AXPWorkflowModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXMReportManagementModule, providers: [
+            {
+                provide: AXMDataSetService,
+                useClass: AXMDataSetServiceImpl,
+            },
+            AXM_REPORT_DEFINITION_PROVIDER,
+            AXM_REPORT_CATEGORY_PROVIDER,
+            {
+                provide: AXP_MENU_PROVIDER,
+                useClass: AXMMenuProvider,
+                multi: true,
+            },
+            // {
+            //     provide: AXP_SEARCH_PROVIDER,
+            //     useClass: AXPReportSearchProvider,
+            //     multi: true,
+            // },
+            // {
+            //     provide: AXP_SEARCH_DEFINITION_PROVIDER,
+            //     useClass: AXPReportSearchDefinitionProvider,
+            //     multi: true,
+            // },
+            {
+                provide: ROUTES,
+                multi: true,
+                useFactory: routesFacory,
+            },
+            provideCommandSetups([
+                {
+                    key: `${RootConfig.entities.report.fullName}:Run`,
+                    command: () => import('./acorex-modules-report-management-run.command-CoXvPC15.mjs').then((c) => c.AXMReportRunCommand),
+                },
+            ]),
+            provideEntity([RootConfig.entities.report.fullName, RootConfig.entities.category.fullName]),
+            {
+                provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                useClass: AXMColumnEvaluatorScopeProvider,
+                multi: true,
+            },
+        ], imports: [AXPDomainModule,
+            AXPWorkflowModule.forChild({
+                actions: {
+                    AXMReportCreateRootWorkflowAction,
+                },
+                workflows: {
+                    'report-create': AXMReportCreateWorkflow,
+                },
+            })] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.6", ngImport: i0, type: AXMReportManagementModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AXPDomainModule,
+                        AXPWorkflowModule.forChild({
+                            actions: {
+                                AXMReportCreateRootWorkflowAction,
+                            },
+                            workflows: {
+                                'report-create': AXMReportCreateWorkflow,
+                            },
+                        }),
+                    ],
+                    exports: [],
+                    declarations: [],
+                    providers: [
+                        {
+                            provide: AXMDataSetService,
+                            useClass: AXMDataSetServiceImpl,
+                        },
+                        AXM_REPORT_DEFINITION_PROVIDER,
+                        AXM_REPORT_CATEGORY_PROVIDER,
+                        {
+                            provide: AXP_MENU_PROVIDER,
+                            useClass: AXMMenuProvider,
+                            multi: true,
+                        },
+                        // {
+                        //     provide: AXP_SEARCH_PROVIDER,
+                        //     useClass: AXPReportSearchProvider,
+                        //     multi: true,
+                        // },
+                        // {
+                        //     provide: AXP_SEARCH_DEFINITION_PROVIDER,
+                        //     useClass: AXPReportSearchDefinitionProvider,
+                        //     multi: true,
+                        // },
+                        {
+                            provide: ROUTES,
+                            multi: true,
+                            useFactory: routesFacory,
+                        },
+                        provideCommandSetups([
+                            {
+                                key: `${RootConfig.entities.report.fullName}:Run`,
+                                command: () => import('./acorex-modules-report-management-run.command-CoXvPC15.mjs').then((c) => c.AXMReportRunCommand),
+                            },
+                        ]),
+                        provideEntity([RootConfig.entities.report.fullName, RootConfig.entities.category.fullName]),
+                        {
+                            provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                            useClass: AXMColumnEvaluatorScopeProvider,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AXMReportManagementModule, RootConfig };
+//# sourceMappingURL=acorex-modules-report-management.mjs.map