@acorex/modules 21.0.0-next.89 → 21.0.0-next.90

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

@@ -1,21 +1,22 @@
-import { AXPDeviceService, AXP_MODULE_MANIFEST_PROVIDER } from '@acorex/platform/core';
+import { AXP_IDENTIFIER_RULES } from '@acorex/modules/identifier-management';
+import { AXP_MODULE_MANIFEST_PROVIDER, AXP_CATALOG_SCOPE_DEFINITION_PROVIDER, AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER } from '@acorex/platform/core';
 import { AXPEntityService, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
 import * as i0 from '@angular/core';
-import { Injectable, inject, input, signal, computed, effect, ViewEncapsulation, ChangeDetectionStrategy, Component, NgModule } from '@angular/core';
-import { AXPCommandService, AXPRuntimeModule } from '@acorex/platform/runtime';
-import { AXP_PAGE_COMPONENT_PROVIDER } from '@acorex/platform/layout/components';
+import { Injectable, inject, NgModule } from '@angular/core';
+import { AXPRuntimeModule } from '@acorex/platform/runtime';
 import { AXPSearchCommandProvider, createEntitySearchCommand, AXPEntityCommandScope, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER, AXP_SEARCH_PROVIDER, AXP_STATUS_PROVIDERS } from '@acorex/platform/common';
 import { AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex/platform/auth';
 import { AXPCommonMenuKeys } from '@acorex/modules/common';
-import * as i2 from '@acorex/core/translation';
-import { AXTranslationModule } from '@acorex/core/translation';
-import { AXPLayoutRendererComponent } from '@acorex/platform/layout/builder';
-import { AXPPageLayoutBaseComponent, AXPPageLayoutBase } from '@acorex/platform/layout/views';
-import { AXPWidgetsCatalog, AXPStatusProvider, AXPSystemActionType, AXPWidgetsList } from '@acorex/platform/contracts';
-import * as i1 from '@angular/common';
-import { CommonModule } from '@angular/common';
+import { AXPStatusProvider, AXPWidgetsCatalog, AXPWidgetsList } from '@acorex/platform/contracts';
+import { AXPTaskManagementCommandKeys } from '@acorex/modules/task-management';
+import { isEmpty, defaultTo, merge, isString, uniq } from 'lodash-es';
 import { createAllQueryView, entityMasterCrudActions, entityMasterRecordActions, AXPEntityCommandScope as AXPEntityCommandScope$1, entityDetailsCrudActions } from '@acorex/platform/layout/entity-contracts';
 
+/** Catalog scope for project-management workflows and related catalogs. */
+const PM_CATALOG_SCOPE = 'project-management.pm';
+/** Canonical entity source for {@link AXPEntityReference.type} on project subjects. */
+const PM_PROJECT_ENTITY_SOURCE = 'ProjectManagement.Project';
+
 const AXPProjectManagementMenuKeys = {
     Root: 'project-management:menu',
     Projects: 'project-management:menu:projects',
@@ -67,8 +68,15 @@ const RootConfig = {
             titlePlural: `@project-management:projects.project-types.plural`,
             icon: 'fa-light fa-rectangle-vertical-history',
         },
+        projectTypeCategory: {
+            name: 'ProjectTypeCategory',
+            title: '@project-management:projects.project-type-categories.title',
+            titlePlural: '@project-management:projects.project-type-categories.plural',
+            icon: 'fa-light fa-layer-group',
+        },
         project: {
             name: 'Project',
+            source: `${config.module}.Project`,
             title: '@project-management:projects.terms.title',
             titlePlural: '@project-management:projects.terms.plural',
             icon: 'fa-light fa-square-kanban',
@@ -76,8 +84,6 @@ const RootConfig = {
     },
 };
 
-const PROJECT_TASK_BOARD_PAGE_COMPONENT_KEY = 'project-task-board-page';
-
 //#region ---- Contracts barrel ----
 //#endregion
 
@@ -151,7 +157,6 @@ class AXMMenuProvider {
                     permissions: [AXMPermissionsKeys.ProjectManagement.ProjectType.Management],
                 },
             },
-            // previously TaskTypes menu was here, now removed with TaskType entity
         ]);
     }
 }
@@ -246,208 +251,6 @@ class AXMSearchCommandProvider extends AXPSearchCommandProvider {
     }
 }
 
-class AXMProjectTaskBoardPageComponentProvider {
-    async components() {
-        return [
-            {
-                key: PROJECT_TASK_BOARD_PAGE_COMPONENT_KEY,
-                loader: () => Promise.resolve().then(function () { return projectTaskBoardPage_component; }).then((m) => m.AXMProjectTaskBoardPageComponent),
-            },
-        ];
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMProjectTaskBoardPageComponentProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMProjectTaskBoardPageComponentProvider }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMProjectTaskBoardPageComponentProvider, decorators: [{
-            type: Injectable
-        }] });
-
-//#region ---- Component ----
-class AXMProjectTaskBoardPageComponent extends AXPPageLayoutBaseComponent {
-    constructor() {
-        super();
-        this.rootContext = input(...(ngDevMode ? [undefined, { debugName: "rootContext" }] : /* istanbul ignore next */ []));
-        this.pageConfig = input(...(ngDevMode ? [undefined, { debugName: "pageConfig" }] : /* istanbul ignore next */ []));
-        this.options = input({}, ...(ngDevMode ? [{ debugName: "options" }] : /* istanbul ignore next */ []));
-        /** Set once after create menu is built from rootContext; prevents re-running. */
-        this.isInitialized = false;
-        /** Menu items built once when rootContext is available. */
-        this.createMenuItems = signal([], ...(ngDevMode ? [{ debugName: "createMenuItems" }] : /* istanbul ignore next */ []));
-        this.deviceService = inject(AXPDeviceService);
-        this.commandService = inject(AXPCommandService);
-        //#endregion
-        //#region ---- Workflow list layout (entity-list with projectId filter) ----
-        /**
-         * Entity-list widget node for WorkflowInstance, filtered by current project.
-         * Only rendered when project id is available.
-         */
-        this.workflowListLayout = computed(() => {
-            const ctx = this.rootContext();
-            const projectId = ctx && typeof ctx === 'object' && 'id' in ctx ? ctx.id : undefined;
-            if (!projectId) {
-                return null;
-            }
-            return {
-                type: AXPWidgetsCatalog.entityList,
-                name: 'project-workflow-instances',
-                path: 'workflowInstances',
-                mode: 'view',
-                options: {
-                    entity: 'WorkflowManagement.WorkflowInstance',
-                    showEntityActions: false,
-                    showToolbar: true,
-                    actions: [
-                        {
-                            command: 'open-entity',
-                            scope: AXPEntityCommandScope.Individual,
-                            priority: 'secondary',
-                            hidden: true,
-                        },
-                        {
-                            command: 'delete-entity',
-                            scope: AXPEntityCommandScope.Individual,
-                            priority: 'secondary',
-                            hidden: true,
-                        },
-                    ],
-                },
-                defaultValue: {
-                    toolbar: {
-                        filters: [
-                            {
-                                field: 'workflowInstance.workflowState.input.projectId',
-                                operator: { type: 'equal' },
-                                value: projectId,
-                                hidden: true,
-                            },
-                        ],
-                    },
-                },
-            };
-        }, ...(ngDevMode ? [{ debugName: "workflowListLayout" }] : /* istanbul ignore next */ []));
-        this.layoutContext = computed(() => ({}), ...(ngDevMode ? [{ debugName: "layoutContext" }] : /* istanbul ignore next */ []));
-        effect(() => {
-            const ctx = this.rootContext();
-            if (ctx == null || this.isInitialized) {
-                return;
-            }
-            const projectType = ctx?.projectType ?? {};
-            const workflows = projectType.workflows ?? [];
-            const items = workflows.filter((w) => !!w?.name);
-            if (!items.length) {
-                this.isInitialized = true;
-                return;
-            }
-            const typedCtx = ctx;
-            console.log('typedCtx', typedCtx);
-            console.log('typedCtx.metaDataForm', typedCtx?.metaDataForm);
-            this.createMenuItems.set([
-                {
-                    title: '@general:actions.create.title',
-                    icon: 'fa-light fa-plus',
-                    color: 'primary',
-                    items: items.map((w) => ({
-                        name: `start-workflow:${w.name}`,
-                        title: w.title ?? w.name,
-                        icon: 'fa-light fa-diagram-project',
-                        command: {
-                            name: 'WorkflowManagement.WorkflowDefinition:Execute',
-                            options: {
-                                workflowId: w.name,
-                                input: {
-                                    metadata: {
-                                        ...(typedCtx?.metaDataForm ?? {}),
-                                        isNeedReview: true,
-                                    },
-                                    projectId: typedCtx?.id,
-                                    projectTypeId: typedCtx?.projectType?.id,
-                                },
-                            },
-                        },
-                    })),
-                },
-            ]);
-            this.isInitialized = true;
-        });
-    }
-    //#endregion
-    //#region ---- Lifecycle ----
-    async ngOnInit() {
-        await super.ngOnInit();
-    }
-    //#endregion
-    //#region ---- Page metadata (AXPPageLayoutBase) ----
-    async getPrimaryMenuItems() {
-        return this.createMenuItems();
-    }
-    async getSecondaryMenuItems() {
-        return [];
-    }
-    async getPageTitle() {
-        return this.translateService.translateAsync('@project-management:projects.tasks.plural');
-    }
-    async getPageBreadcrumbs() {
-        return [];
-    }
-    async execute(command) {
-        if (command.name === 'WorkflowManagement.WorkflowDefinition:Execute') {
-            await this.commandService.execute(command.name, command.options);
-        }
-    }
-    //#endregion
-    static { this.COMPONENT_KEY = PROJECT_TASK_BOARD_PAGE_COMPONENT_KEY; }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMProjectTaskBoardPageComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "21.2.9", type: AXMProjectTaskBoardPageComponent, isStandalone: true, selector: "axm-project-task-board-page", inputs: { rootContext: { classPropertyName: "rootContext", publicName: "rootContext", isSignal: true, isRequired: false, transformFunction: null }, pageConfig: { classPropertyName: "pageConfig", publicName: "pageConfig", isSignal: true, isRequired: false, transformFunction: null }, options: { classPropertyName: "options", publicName: "options", isSignal: true, isRequired: false, transformFunction: null } }, host: { classAttribute: "ax-flex ax-flex-col ax-flex-1 ax-min-h-0 ax-h-full" }, providers: [
-            {
-                provide: AXPPageLayoutBase,
-                useExisting: AXMProjectTaskBoardPageComponent,
-            },
-        ], usesInheritance: true, ngImport: i0, template: `
-    <div class="ax-flex-1 ax-min-h-0 ax-h-full ax-flex ax-flex-col">
-      @if (workflowListLayout(); as layout) {
-        <axp-layout-renderer [layout]="layout" [context]="layoutContext()" class="ax-flex-1 ax-min-h-0 ax-w-full" />
-      } @else {
-        <div class="ax-p-4 ax-text-sm ax-text-muted">
-          {{ '@general:state-message.empty.title' | translate | async }}
-        </div>
-      }
-    </div>
-  `, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: AXPLayoutRendererComponent, selector: "axp-layout-renderer", inputs: ["layout", "context", "look", "mode"], outputs: ["contextChange", "contextInitiated", "validityChange"] }, { kind: "ngmodule", type: AXTranslationModule }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "pipe", type: i2.AXTranslatorPipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMProjectTaskBoardPageComponent, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'axm-project-task-board-page',
-                    standalone: true,
-                    imports: [CommonModule, AXPLayoutRendererComponent, AXTranslationModule],
-                    template: `
-    <div class="ax-flex-1 ax-min-h-0 ax-h-full ax-flex ax-flex-col">
-      @if (workflowListLayout(); as layout) {
-        <axp-layout-renderer [layout]="layout" [context]="layoutContext()" class="ax-flex-1 ax-min-h-0 ax-w-full" />
-      } @else {
-        <div class="ax-p-4 ax-text-sm ax-text-muted">
-          {{ '@general:state-message.empty.title' | translate | async }}
-        </div>
-      }
-    </div>
-  `,
-                    changeDetection: ChangeDetectionStrategy.OnPush,
-                    encapsulation: ViewEncapsulation.None,
-                    host: { class: 'ax-flex ax-flex-col ax-flex-1 ax-min-h-0 ax-h-full' },
-                    providers: [
-                        {
-                            provide: AXPPageLayoutBase,
-                            useExisting: AXMProjectTaskBoardPageComponent,
-                        },
-                    ],
-                }]
-        }], ctorParameters: () => [], propDecorators: { rootContext: [{ type: i0.Input, args: [{ isSignal: true, alias: "rootContext", required: false }] }], pageConfig: [{ type: i0.Input, args: [{ isSignal: true, alias: "pageConfig", required: false }] }], options: [{ type: i0.Input, args: [{ isSignal: true, alias: "options", required: false }] }] } });
-
-var projectTaskBoardPage_component = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    AXMProjectTaskBoardPageComponent: AXMProjectTaskBoardPageComponent
-});
-
 //#region ----   Imports   ----
 //#endregion
 //#region ----   Project Status Provider   ----
@@ -516,17 +319,280 @@ class AXMProjectStatusProvider extends AXPStatusProvider {
 }
 //#endregion
 
+//#endregion
+//#region ---- Constants ----
+const WORKFLOW_DEFINITION = 'WorkflowManagement.WorkflowDefinition';
+//#endregion
+//#region ---- Provider ----
+class AXMProjectManagementCatalogScopeDefinitionProvider {
+    async items() {
+        return [
+            {
+                name: PM_CATALOG_SCOPE,
+                title: '@project-management:catalog-scopes.pm.title',
+                description: '@project-management:catalog-scopes.pm.description',
+                targets: [WORKFLOW_DEFINITION],
+                icon: 'fa-light fa-diagram-project',
+                cssClass: 'ax-secondary-lighter',
+                order: 15,
+            },
+        ];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMProjectManagementCatalogScopeDefinitionProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMProjectManagementCatalogScopeDefinitionProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMProjectManagementCatalogScopeDefinitionProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ---- Imports ----
+//#endregion
+/**
+ * Expression-evaluator scope for project "Start task" dropdown items (allowed task types).
+ */
+class AXMProjectManagementAllowedTaskTypesExpressionEvaluatorScopeProvider {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.entityService = inject(AXPEntityService);
+        //#endregion
+    }
+    //#endregion
+    //#region ---- AXPExpressionEvaluatorScopeProvider ----
+    async provide(context) {
+        context.addScope(RootConfig.module.name, {
+            AllowedTaskTypes: async (projectTypeIdRaw) => {
+                try {
+                    const projectTypeId = typeof projectTypeIdRaw === 'string' ? projectTypeIdRaw.trim() : '';
+                    if (!projectTypeId) {
+                        return [];
+                    }
+                    const allowedRows = await this.loadAllowedTaskTypes(projectTypeId);
+                    if (isEmpty(allowedRows)) {
+                        return [];
+                    }
+                    return allowedRows.map((row) => this.buildAction(row));
+                }
+                catch (error) {
+                    console.error(`${RootConfig.module.name}.AllowedTaskTypes failed:`, error instanceof Error ? error.message : error);
+                    return [];
+                }
+            },
+        });
+    }
+    //#endregion
+    //#region ---- Helpers ----
+    async loadAllowedTaskTypes(projectTypeId) {
+        const projectType = (await this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.projectType.name)
+            .data()
+            .byKey(projectTypeId));
+        if (!projectType) {
+            return [];
+        }
+        const taskTypeIds = this.resolveAllowedTaskTypeIds(projectType);
+        const enriched = [];
+        for (const taskTypeId of taskTypeIds) {
+            const trimmedId = taskTypeId?.trim();
+            if (!trimmedId) {
+                continue;
+            }
+            const taskTypeDetail = (await this.entityService
+                .withEntity('TaskManagement', 'TaskType')
+                .data()
+                .byKey(trimmedId));
+            if (!taskTypeDetail?.isActive) {
+                continue;
+            }
+            enriched.push({
+                taskTypeId: trimmedId,
+                projectTypeId,
+                taskTypeDetail: {
+                    id: taskTypeDetail.id,
+                    title: taskTypeDetail.title,
+                    workflowConfig: taskTypeDetail.workflowConfig,
+                    isActive: taskTypeDetail.isActive,
+                },
+            });
+        }
+        return enriched;
+    }
+    resolveAllowedTaskTypeIds(projectType) {
+        const fromRefs = projectType.allowedTaskTypes?.map((row) => row.id).filter(Boolean) ?? [];
+        if (!isEmpty(fromRefs)) {
+            return fromRefs;
+        }
+        return defaultTo(projectType.allowedTaskTypeIds, []).filter((id) => typeof id === 'string' && id.trim().length > 0);
+    }
+    buildAction(row) {
+        const taskTypeId = row.taskTypeId;
+        const taskTypeTitle = row.taskTypeDetail?.title ?? taskTypeId;
+        const workflowConfig = row.taskTypeDetail?.workflowConfig;
+        const workflowId = workflowConfig?.workflowName?.trim();
+        const guidedFlowCommand = workflowId
+            ? {
+                name: AXPTaskManagementCommandKeys.Task.StartFlow,
+                options: {
+                    workflowId,
+                    input: merge(defaultTo(workflowConfig?.defaultInput, {}), {
+                        taskTypeId,
+                        taskTypeTitle,
+                        projectTypeId: row.projectTypeId,
+                        subjectRef: {
+                            type: PM_PROJECT_ENTITY_SOURCE,
+                            id: '{{ context.eval("id") }}',
+                            title: '{{ context.eval("title") }}',
+                        },
+                    }),
+                },
+            }
+            : undefined;
+        const notConfiguredCommand = {
+            name: 'workflow-activity:show-toast',
+            options: {
+                message: '@project-management:projects.messages.task-type-not-configured',
+                type: 'warning',
+            },
+        };
+        return {
+            name: `start-project-task-${taskTypeId}`,
+            title: taskTypeTitle,
+            icon: 'fa-light fa-play',
+            color: 'default',
+            command: guidedFlowCommand ?? notConfiguredCommand,
+            priority: 'primary',
+            type: 'create',
+            scope: AXPEntityCommandScope.TypeLevel,
+        };
+    }
+}
+
+//#region ---- Imports ----
+//#endregion
+/**
+ * Expression-evaluator scope for resolving allowed document type names from a project record.
+ * Unions document type names configured on each allowed TaskType for the project's ProjectType.
+ */
+class AXMProjectManagementDocumentTypeNamesExpressionEvaluatorScopeProvider {
+    constructor() {
+        //#region ---- Services & Dependencies ----
+        this.entityService = inject(AXPEntityService);
+        //#endregion
+    }
+    //#endregion
+    //#region ---- AXPExpressionEvaluatorScopeProvider ----
+    async provide(context) {
+        context.addScope(RootConfig.module.name, {
+            resolveDocumentTypeNames: async (projectIdRaw) => {
+                try {
+                    const projectId = isString(projectIdRaw) ? projectIdRaw.trim() : '';
+                    if (!projectId) {
+                        return [];
+                    }
+                    return await this.loadAllowedDocumentTypeNamesForProject(projectId);
+                }
+                catch (error) {
+                    console.error(`${RootConfig.module.name}.resolveDocumentTypeNames failed:`, error instanceof Error ? error.message : error);
+                    return [];
+                }
+            },
+        });
+    }
+    //#endregion
+    //#region ---- Helpers ----
+    async loadAllowedDocumentTypeNamesForProject(projectId) {
+        const project = (await this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.project.name)
+            .data()
+            .byKey(projectId));
+        if (!project) {
+            return [];
+        }
+        const projectTypeId = this.resolveProjectTypeId(project);
+        if (!projectTypeId) {
+            return [];
+        }
+        const projectType = (await this.entityService
+            .withEntity(RootConfig.module.name, RootConfig.entities.projectType.name)
+            .data()
+            .byKey(projectTypeId));
+        if (!projectType) {
+            return [];
+        }
+        const taskTypeIds = this.resolveAllowedTaskTypeIds(projectType);
+        if (isEmpty(taskTypeIds)) {
+            return [];
+        }
+        const names = [];
+        for (const taskTypeId of taskTypeIds) {
+            const trimmedId = taskTypeId?.trim();
+            if (!trimmedId) {
+                continue;
+            }
+            const taskType = (await this.entityService
+                .withEntity('TaskManagement', 'TaskType')
+                .data()
+                .byKey(trimmedId));
+            if (!taskType?.isActive) {
+                continue;
+            }
+            names.push(...this.extractDocumentTypeNames(taskType));
+        }
+        return uniq(names.filter((name) => name.trim().length > 0));
+    }
+    resolveProjectTypeId(project) {
+        const fromNested = project.projectType?.id;
+        if (isString(fromNested) && fromNested.trim()) {
+            return fromNested.trim();
+        }
+        const raw = project.projectTypeId;
+        if (isString(raw) && raw.trim()) {
+            return raw.trim();
+        }
+        if (raw && typeof raw === 'object' && isString(raw.id)) {
+            return (raw.id ?? '').trim();
+        }
+        return '';
+    }
+    resolveAllowedTaskTypeIds(projectType) {
+        const fromRefs = projectType.allowedTaskTypes?.map((row) => row.id).filter(Boolean) ?? [];
+        if (!isEmpty(fromRefs)) {
+            return fromRefs;
+        }
+        return defaultTo(projectType.allowedTaskTypeIds, []).filter((id) => isString(id) && id.trim().length > 0);
+    }
+    extractDocumentTypeNames(taskType) {
+        return (taskType.documentTypes ?? [])
+            .map((row) => row?.name)
+            .filter((name) => isString(name) && name.trim().length > 0)
+            .map((name) => name.trim());
+    }
+}
+
+const AXM_PROJECT_CODE_IDENTIFIER_RULE = {
+    id: 'project-code',
+    title: 'Project Code',
+    entity: RootConfig.entities.project.source,
+    /** `PRJ-` + calendar year + padded sequence. */
+    pattern: 'PRJ-{date:YYYY}-{seq:4}',
+    enabled: true,
+    priority: 1,
+    scopeConfig: { byTenant: true, period: 'yearly', minValue: 1, blockSize: 0 },
+};
+
 class AXMProjectManagementModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMProjectManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: AXMProjectManagementModule, imports: [AXPRuntimeModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AXMProjectManagementModule, providers: [
-            // Module Manifest Provider
+            {
+                provide: AXP_IDENTIFIER_RULES,
+                multi: true,
+                useValue: AXM_PROJECT_CODE_IDENTIFIER_RULE,
+            },
             {
                 provide: AXP_MODULE_MANIFEST_PROVIDER,
                 useValue: ProjectManagementManifest,
                 multi: true,
             },
-            // Provider references (now using tokens)
             {
                 provide: AXP_PERMISSION_DEFINITION_PROVIDER,
                 useClass: AXMPermissionDefinitionProvider,
@@ -553,13 +619,23 @@ class AXMProjectManagementModule {
                 multi: true,
             },
             {
-                provide: AXP_PAGE_COMPONENT_PROVIDER,
+                provide: AXP_STATUS_PROVIDERS,
+                useClass: AXMProjectStatusProvider,
                 multi: true,
-                useClass: AXMProjectTaskBoardPageComponentProvider,
             },
             {
-                provide: AXP_STATUS_PROVIDERS,
-                useClass: AXMProjectStatusProvider,
+                provide: AXP_CATALOG_SCOPE_DEFINITION_PROVIDER,
+                useClass: AXMProjectManagementCatalogScopeDefinitionProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                useClass: AXMProjectManagementAllowedTaskTypesExpressionEvaluatorScopeProvider,
+                multi: true,
+            },
+            {
+                provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                useClass: AXMProjectManagementDocumentTypeNamesExpressionEvaluatorScopeProvider,
                 multi: true,
             },
         ], imports: [AXPRuntimeModule] }); }
@@ -569,19 +645,20 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
             args: [{
                     imports: [
                         AXPRuntimeModule,
-                        // Entity Modules
-                        // Feature Modules
                     ],
                     exports: [],
                     declarations: [],
                     providers: [
-                        // Module Manifest Provider
+                        {
+                            provide: AXP_IDENTIFIER_RULES,
+                            multi: true,
+                            useValue: AXM_PROJECT_CODE_IDENTIFIER_RULE,
+                        },
                         {
                             provide: AXP_MODULE_MANIFEST_PROVIDER,
                             useValue: ProjectManagementManifest,
                             multi: true,
                         },
-                        // Provider references (now using tokens)
                         {
                             provide: AXP_PERMISSION_DEFINITION_PROVIDER,
                             useClass: AXMPermissionDefinitionProvider,
@@ -608,13 +685,23 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                             multi: true,
                         },
                         {
-                            provide: AXP_PAGE_COMPONENT_PROVIDER,
+                            provide: AXP_STATUS_PROVIDERS,
+                            useClass: AXMProjectStatusProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_CATALOG_SCOPE_DEFINITION_PROVIDER,
+                            useClass: AXMProjectManagementCatalogScopeDefinitionProvider,
                             multi: true,
-                            useClass: AXMProjectTaskBoardPageComponentProvider,
                         },
                         {
-                            provide: AXP_STATUS_PROVIDERS,
-                            useClass: AXMProjectStatusProvider,
+                            provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                            useClass: AXMProjectManagementAllowedTaskTypesExpressionEvaluatorScopeProvider,
+                            multi: true,
+                        },
+                        {
+                            provide: AXP_EXPRESSION_EVALUATOR_SCOPE_PROVIDER,
+                            useClass: AXMProjectManagementDocumentTypeNamesExpressionEvaluatorScopeProvider,
                             multi: true,
                         },
                     ],
@@ -636,7 +723,17 @@ async function projectFactory() {
             },
         },
         plugins: [
+            { name: 'comments', options: { display: 'page' } },
             { name: 'history' },
+            { name: 'archive' },
+            { name: 'identifier', options: { field: 'code', rule: 'project-code' } },
+            {
+                name: 'documents',
+                options: {
+                    documentTypeNames: `{{ await ${RootConfig.module.name}.resolveDocumentTypeNames(context.eval("id")) }}`,
+                },
+            },
+            { name: 'unique-fields', options: { fields: 'code', scope: 'global' } },
             {
                 name: 'status',
                 options: {
@@ -680,7 +777,7 @@ async function projectFactory() {
                             },
                         },
                         priority: 'primary',
-                        type: AXPSystemActionType.Create,
+                        type: 'create',
                         scope: AXPEntityCommandScope$1.TypeLevel,
                     },
                     ...entityDetailsCrudActions('projectId', { create: false }),
@@ -690,23 +787,48 @@ async function projectFactory() {
                     type: 'page-list',
                 },
             },
-        ],
-        pages: [
             {
-                componentKey: PROJECT_TASK_BOARD_PAGE_COMPONENT_KEY,
-                title: '@project-management:projects.tasks.plural',
-                icon: 'fa-light fa-list-check',
-                layout: { order: 20 },
+                entity: 'TaskManagement.Task',
+                title: '@task-management:task.plural-title',
+                columns: ['title', 'taskTypeId', 'statusId', 'dueDate', 'progress'],
+                conditions: [
+                    { name: 'subjectRef.type', operator: { type: 'equal' }, value: PM_PROJECT_ENTITY_SOURCE },
+                    { name: 'subjectRef.id', operator: { type: 'equal' }, value: '{{ context.eval("id") }}' },
+                ],
+                excludeProperties: ['subjectRef'],
+                actions: [
+                    {
+                        title: '@project-management:projects.entities.project.related-entities.task-start.title',
+                        icon: 'fa-light fa-play',
+                        command: {
+                            name: 'Entity:Create',
+                            options: {
+                                process: {
+                                    redirect: false,
+                                    canCreateNewOne: true,
+                                    data: {},
+                                },
+                            },
+                        },
+                        priority: 'primary',
+                        type: 'create',
+                        scope: AXPEntityCommandScope$1.TypeLevel,
+                        items: `{{ await ${RootConfig.module.name}.AllowedTaskTypes(context.eval("projectType.id")) }}`,
+                    },
+                    ...entityDetailsCrudActions('subjectRef.id', { create: false, edit: true, delete: true, view: true }),
+                ],
+                layout: { type: 'page-list', position: 'after', order: 10 },
             },
         ],
         groups: [
             { id: 'basic-info', title: `@general:terms.interface.basic-info` },
-            { id: 'additional-info', title: '@general:terms.interface.additional-info' },
+            { id: 'organization-parties', title: `@project-management:projects.groups.organization-parties` },
+            { id: 'schedule', title: `@project-management:projects.groups.schedule` },
         ],
         properties: [
             {
-                name: 'name',
-                title: '@general:terms.common.name',
+                name: 'code',
+                title: '@general:terms.common.code',
                 groupId: 'basic-info',
                 options: {
                     sort: {
@@ -723,19 +845,44 @@ async function projectFactory() {
                 },
                 schema: {
                     dataType: 'string',
+                    unique: { enabled: true },
                     interface: {
                         type: AXPWidgetsCatalog.text,
+                        options: {
+                            disabled: true,
+                        },
                     },
                 },
-                validations: [
-                    {
-                        rule: 'required',
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'title',
+                title: '@general:terms.common.title',
+                groupId: 'basic-info',
+                options: {
+                    sort: {
+                        enabled: true,
                     },
-                ],
+                    filter: {
+                        advance: {
+                            enabled: true,
+                        },
+                        inline: {
+                            enabled: true,
+                        },
+                    },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.text,
+                    },
+                },
+                validations: [{ rule: 'required' }],
             },
             {
                 name: 'projectTypeId',
-                title: '@project-management:projects.terms.projectTypeId',
+                title: '@general:terms.common.type',
                 groupId: 'basic-info',
                 options: {
                     sort: {
@@ -761,16 +908,77 @@ async function projectFactory() {
                             expose: [
                                 { source: 'id', target: 'projectType.id' },
                                 { source: 'title', target: 'projectType.title' },
-                                { source: 'workflows', target: 'projectType.workflows' },
                             ],
                         },
                     },
                 },
-                validations: [
-                    {
-                        rule: 'required',
+                validations: [{ rule: 'required' }],
+            },
+            {
+                name: 'customerId',
+                title: '@project-management:projects.terms.customerId',
+                groupId: 'organization-parties',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.LookupBox,
+                        options: {
+                            entity: 'CustomerManagement.Customer',
+                            textField: 'party.title',
+                            valueField: 'id',
+                            look: 'select',
+                            columns: ['party.code', 'party.title'],
+                            expose: [
+                                { source: 'id', target: 'customer.id' },
+                                { source: 'party.title', target: 'customer.title' },
+                                { source: 'partyId', target: 'customer.partyId' },
+                            ],
+                        },
                     },
-                ],
+                },
+            },
+            {
+                name: 'partyLocationId',
+                title: '@project-management:projects.terms.location',
+                groupId: 'organization-parties',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: false } },
+                },
+                schema: {
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsList.Editors.LookupBox,
+                        options: {
+                            entity: 'BusinessCore.PartyLocation',
+                            textField: 'location.title',
+                            valueField: 'id',
+                            look: 'select',
+                            columns: ['location.title', 'locationRole.title', 'location.street1', 'location.city.title'],
+                            expose: [
+                                { source: 'id', target: 'partyLocation.id' },
+                                { source: 'location.title', target: 'partyLocation.title' },
+                                { source: 'location.street1', target: 'partyLocation.location.street1' },
+                                { source: 'location.city.title', target: 'partyLocation.location.city.title' },
+                            ],
+                            filter: {
+                                logic: 'and',
+                                filters: [
+                                    {
+                                        field: 'partyId',
+                                        operator: { type: 'equal' },
+                                        value: '{{ context.eval("customer.partyId") }}',
+                                    },
+                                ],
+                            },
+                            triggers: [{ event: "{{ events.context('customerId') }}", action: `{{ widget.refresh() }}` }],
+                        },
+                    },
+                },
             },
             {
                 name: 'description',
@@ -797,11 +1005,43 @@ async function projectFactory() {
                 },
             },
             {
-                name: 'dueDate',
-                title: '@project-management:projects.terms.duedate',
-                groupId: 'basic-info',
+                name: 'startDate',
+                title: '@project-management:projects.terms.startDate',
+                groupId: 'schedule',
                 options: {
-                    sort: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                schema: {
+                    dataType: 'date',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                        options: { showTime: false },
+                    },
+                },
+            },
+            {
+                name: 'endDate',
+                title: '@project-management:projects.terms.endDate',
+                groupId: 'schedule',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: true } },
+                },
+                schema: {
+                    dataType: 'date',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                        options: { showTime: false },
+                    },
+                },
+            },
+            {
+                name: 'dueDate',
+                title: '@project-management:projects.terms.duedate',
+                groupId: 'schedule',
+                options: {
+                    sort: {
                         enabled: true,
                     },
                     filter: {
@@ -817,12 +1057,46 @@ async function projectFactory() {
                     dataType: 'date',
                     interface: {
                         type: AXPWidgetsCatalog.dateTime,
+                        options: { showTime: false },
+                    },
+                },
+            },
+            {
+                name: 'actualStartDate',
+                title: '@project-management:projects.terms.actualStartDate',
+                groupId: 'schedule',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: false } },
+                },
+                schema: {
+                    dataType: 'date',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                        options: { showTime: false },
+                    },
+                },
+            },
+            {
+                name: 'actualEndDate',
+                title: '@project-management:projects.terms.actualEndDate',
+                groupId: 'schedule',
+                options: {
+                    sort: { enabled: true },
+                    filter: { advance: { enabled: true }, inline: { enabled: false } },
+                },
+                schema: {
+                    dataType: 'date',
+                    interface: {
+                        type: AXPWidgetsCatalog.dateTime,
+                        options: { showTime: false },
                     },
                 },
             },
         ],
         columns: [
-            { name: 'name' },
+            { name: 'code' },
+            { name: 'title' },
             { name: 'dueDate' },
             { name: 'description' },
             { name: 'projectTypeId', options: { dataPath: 'projectType' } },
@@ -831,150 +1105,157 @@ async function projectFactory() {
             master: {
                 create: {
                     sections: [
-                        {
-                            id: 'basic-info',
-                        },
+                        { id: 'basic-info' },
+                        { id: 'organization-parties' },
+                        { id: 'schedule' },
                     ],
                     properties: [
                         {
-                            name: 'name',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 1,
-                                    },
-                                },
-                            },
+                            name: 'code',
+                            layout: { positions: { lg: { colSpan: 2, order: 1 } } },
+                        },
+                        {
+                            name: 'title',
+                            layout: { positions: { lg: { colSpan: 6, order: 2 } } },
                         },
                         {
                             name: 'projectTypeId',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 2,
-                                    },
-                                },
-                            },
+                            layout: { positions: { lg: { colSpan: 4, order: 3 } } },
+                        },
+                        {
+                            name: 'description',
+                            layout: { positions: { lg: { colSpan: 12, order: 4 } } },
+                        },
+                        {
+                            name: 'customerId',
+                            layout: { positions: { lg: { colSpan: 6, order: 1 } } },
+                        },
+                        {
+                            name: 'partyLocationId',
+                            layout: { positions: { lg: { colSpan: 6, order: 2 } } },
+                        },
+                        {
+                            name: 'startDate',
+                            layout: { positions: { lg: { colSpan: 4, order: 1 } } },
+                        },
+                        {
+                            name: 'endDate',
+                            layout: { positions: { lg: { colSpan: 4, order: 2 } } },
                         },
                         {
                             name: 'dueDate',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 3,
-                                    },
-                                },
-                            },
+                            layout: { positions: { lg: { colSpan: 4, order: 3 } } },
                         },
                         {
-                            name: 'description',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                        order: 4,
-                                    },
-                                },
-                            },
+                            name: 'actualStartDate',
+                            layout: { positions: { lg: { colSpan: 4, order: 4 } } },
+                        },
+                        {
+                            name: 'actualEndDate',
+                            layout: { positions: { lg: { colSpan: 4, order: 5 } } },
                         },
                     ],
                 },
                 update: {
                     sections: [
-                        {
-                            id: 'basic-info',
-                        },
+                        { id: 'basic-info' },
+                        { id: 'organization-parties' },
+                        { id: 'schedule' },
                     ],
                     properties: [
                         {
-                            name: 'name',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 1,
-                                    },
-                                },
-                            },
+                            name: 'code',
+                            layout: { positions: { lg: { colSpan: 2, order: 1 } } },
                         },
                         {
-                            name: 'dueDate',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 2,
-                                    },
-                                },
-                            },
+                            name: 'title',
+                            layout: { positions: { lg: { colSpan: 6, order: 2 } } },
                         },
                         {
                             name: 'description',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                        order: 3,
-                                    },
-                                },
-                            },
+                            layout: { positions: { lg: { colSpan: 12, order: 3 } } },
+                        },
+                        {
+                            name: 'customerId',
+                            layout: { positions: { lg: { colSpan: 6, order: 1 } } },
+                        },
+                        {
+                            name: 'partyLocationId',
+                            layout: { positions: { lg: { colSpan: 6, order: 2 } } },
+                        },
+                        {
+                            name: 'startDate',
+                            layout: { positions: { lg: { colSpan: 4, order: 1 } } },
+                        },
+                        {
+                            name: 'endDate',
+                            layout: { positions: { lg: { colSpan: 4, order: 2 } } },
+                        },
+                        {
+                            name: 'dueDate',
+                            layout: { positions: { lg: { colSpan: 4, order: 3 } } },
+                        },
+                        {
+                            name: 'actualStartDate',
+                            layout: { positions: { lg: { colSpan: 4, order: 4 } } },
+                        },
+                        {
+                            name: 'actualEndDate',
+                            layout: { positions: { lg: { colSpan: 4, order: 5 } } },
                         },
                     ],
                 },
                 single: {
-                    title: '{{name}}',
+                    title: '{{title}}',
                     sections: [
-                        {
-                            id: 'basic-info',
-                        },
+                        { id: 'basic-info' },
+                        { id: 'organization-parties' },
+                        { id: 'schedule' },
                     ],
                     properties: [
                         {
-                            name: 'name',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 1,
-                                    },
-                                },
-                            },
+                            name: 'code',
+                            layout: { positions: { lg: { colSpan: 2, order: 1 } } },
+                        },
+                        {
+                            name: 'title',
+                            layout: { positions: { lg: { colSpan: 6, order: 2 } } },
                         },
                         {
                             name: 'projectTypeId',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 2,
-                                    },
-                                },
-                            },
+                            layout: { positions: { lg: { colSpan: 4, order: 3 } } },
+                        },
+                        {
+                            name: 'description',
+                            layout: { positions: { lg: { colSpan: 12, order: 4 } } },
+                        },
+                        {
+                            name: 'customerId',
+                            layout: { positions: { lg: { colSpan: 6, order: 1 } } },
+                        },
+                        {
+                            name: 'partyLocationId',
+                            layout: { positions: { lg: { colSpan: 6, order: 2 } } },
+                        },
+                        {
+                            name: 'startDate',
+                            layout: { positions: { lg: { colSpan: 4, order: 1 } } },
+                        },
+                        {
+                            name: 'endDate',
+                            layout: { positions: { lg: { colSpan: 4, order: 2 } } },
                         },
                         {
                             name: 'dueDate',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 6,
-                                        order: 3,
-                                    },
-                                },
-                            },
+                            layout: { positions: { lg: { colSpan: 4, order: 3 } } },
                         },
                         {
-                            name: 'description',
-                            layout: {
-                                positions: {
-                                    lg: {
-                                        colSpan: 12,
-                                        order: 4,
-                                    },
-                                },
-                            },
+                            name: 'actualStartDate',
+                            layout: { positions: { lg: { colSpan: 4, order: 4 } } },
+                        },
+                        {
+                            name: 'actualEndDate',
+                            layout: { positions: { lg: { colSpan: 4, order: 5 } } },
                         },
                     ],
                     actions: [...entityMasterRecordActions()],
@@ -983,7 +1264,7 @@ async function projectFactory() {
                     actions: [...entityMasterCrudActions()],
                     views: [
                         createAllQueryView({
-                            sorts: [{ name: 'projectName', dir: 'asc' }],
+                            sorts: [{ name: 'title', dir: 'asc' }],
                         }),
                     ],
                 },
@@ -1031,12 +1312,12 @@ async function projectMemeberFactory() {
                         type: AXPWidgetsList.Editors.LookupBox,
                         options: {
                             entity: `${RootConfig.module.name}.${RootConfig.entities.project.name}`,
-                            textField: 'projectName',
+                            textField: 'title',
                             valueField: 'id',
                             look: 'select',
                             expose: [
                                 { source: 'id', target: 'project.id' },
-                                { source: 'projectName', target: 'project.displayName' },
+                                { source: 'title', target: 'project.displayName' },
                                 { source: 'projectTypeId', target: 'project.projectTypeId' },
                             ],
                         },
@@ -1170,7 +1451,6 @@ var index$2 = /*#__PURE__*/Object.freeze({
 });
 
 async function projectTypeFactory() {
-    const i18n = RootConfig.config.i18n;
     const entityDef = {
         module: RootConfig.module.name,
         name: RootConfig.entities.projectType.name,
@@ -1179,6 +1459,19 @@ async function projectTypeFactory() {
         plugins: [
             {
                 name: 'meta-data-builder',
+                options: {
+                    display: {
+                        section: { enabled: false },
+                        page: { enabled: true },
+                    },
+                },
+            },
+            {
+                name: 'category',
+                options: {
+                    appearance: { icon: true, color: true },
+                    metaData: { enabled: true },
+                },
             },
         ],
         formats: {
@@ -1195,19 +1488,11 @@ async function projectTypeFactory() {
                 title: RootConfig.entities.projectTypeRoleType.titlePlural,
                 columns: ['title', 'description'],
                 conditions: [{ name: 'projectTypeId', operator: { type: 'equal' }, value: '{{ context.eval("id") }}' }],
-                actions: [...entityDetailsCrudActions('projectTypeId')]
-                // {
-                //   title: '@general:actions.create.title',
-                //   command: { name: 'Entity:Create', options: { process: { redirect: false, canCreateNewOne: true } } },
-                //   priority: 'primary',
-                //   type: 'create',
-                //   scope: AXPEntityCommandScope.TypeLevel,
-                // },
-                ,
+                actions: [...entityDetailsCrudActions('projectTypeId')],
                 layout: {
                     type: 'page-list',
                 },
-            }
+            },
         ],
         groups: [
             {
@@ -1246,8 +1531,8 @@ async function projectTypeFactory() {
                 ],
             },
             {
-                name: 'taskTypeIds',
-                title: '@workflow-management:workflow-definitions.entities.workflow-definition.plural',
+                name: 'description',
+                title: '@general:terms.common.description',
                 groupId: 'section',
                 options: {
                     sort: {
@@ -1263,58 +1548,63 @@ async function projectTypeFactory() {
                     },
                 },
                 schema: {
-                    dataType: 'array',
+                    dataType: 'string',
+                    interface: {
+                        type: AXPWidgetsCatalog.largeText,
+                    },
+                },
+            },
+            {
+                name: 'allowedTaskTypeIds',
+                title: '@project-management:projects.project-type-allowed-task-types.plural',
+                groupId: 'section',
+                schema: {
+                    dataType: 'object',
                     interface: {
                         type: AXPWidgetsCatalog.lookup,
                         options: {
-                            entity: 'WorkflowManagement.WorkflowDefinition',
+                            entity: 'TaskManagement.TaskType',
+                            textField: 'title',
+                            valueField: 'id',
+                            columns: ['name', 'title'],
                             multiple: true,
                             expose: [
-                                { source: 'name', target: 'workflows.{name}' },
-                                { source: 'title', target: 'workflows.{title}' },
+                                { source: 'id', target: 'allowedTaskTypes.{id}' },
+                                { source: 'title', target: 'allowedTaskTypes.{title}' },
+                                { source: 'name', target: 'allowedTaskTypes.{name}' },
                             ],
                         },
                     },
                 },
-            },
-            {
-                name: 'description',
-                title: '@general:terms.common.description',
-                groupId: 'section',
                 options: {
-                    sort: {
-                        enabled: true,
-                    },
-                    filter: {
-                        advance: {
-                            enabled: true,
-                        },
-                        inline: {
-                            enabled: true,
-                        },
-                    },
+                    sort: { enabled: false },
+                    filter: { advance: { enabled: true }, inline: { enabled: false } },
                 },
+            },
+            {
+                name: 'allowedTaskTypes',
+                title: '@project-management:projects.project-type-allowed-task-types.plural',
                 schema: {
-                    dataType: 'string',
+                    dataType: 'array',
                     interface: {
-                        type: AXPWidgetsCatalog.largeText,
+                        type: AXPWidgetsCatalog.text,
                     },
-                }
+                },
+                options: {
+                    sort: { enabled: false },
+                    filter: { advance: { enabled: false }, inline: { enabled: false } },
+                },
             },
         ],
         columns: [
             { name: 'title' },
-            { name: 'taskTypeIds', options: { dataPath: 'workflows' } },
             { name: 'description' },
+            { name: 'allowedTaskTypeIds', options: { dataPath: 'allowedTaskTypes' } },
         ],
         interfaces: {
             master: {
                 create: {
-                    sections: [
-                        {
-                            id: 'section',
-                        },
-                    ],
+                    sections: [{ id: 'section' }],
                     properties: [
                         {
                             name: 'title',
@@ -1328,23 +1618,22 @@ async function projectTypeFactory() {
                             },
                         },
                         {
-                            name: 'taskTypeIds',
-                            dataPath: 'taskTypes',
+                            name: 'description',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
                                         order: 2,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'description',
+                            name: 'allowedTaskTypeIds',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
                                         order: 3,
                                     },
                                 },
@@ -1353,11 +1642,7 @@ async function projectTypeFactory() {
                     ],
                 },
                 update: {
-                    sections: [
-                        {
-                            id: 'section',
-                        },
-                    ],
+                    sections: [{ id: 'section' }],
                     properties: [
                         {
                             name: 'title',
@@ -1371,23 +1656,22 @@ async function projectTypeFactory() {
                             },
                         },
                         {
-                            name: 'taskTypeIds',
-                            dataPath: 'taskTypes',
+                            name: 'description',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
                                         order: 2,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'description',
+                            name: 'allowedTaskTypeIds',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
                                         order: 3,
                                     },
                                 },
@@ -1422,23 +1706,22 @@ async function projectTypeFactory() {
                             },
                         },
                         {
-                            name: 'taskTypeIds',
-                            dataPath: 'taskTypes',
+                            name: 'description',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
                                         order: 2,
                                     },
                                 },
                             },
                         },
                         {
-                            name: 'description',
+                            name: 'allowedTaskTypeIds',
                             layout: {
                                 positions: {
                                     lg: {
-                                        colSpan: 6,
+                                        colSpan: 12,
                                         order: 3,
                                     },
                                 },