@acorex/modules 20.7.4 → 20.7.6

package/fesm2022/acorex-modules-human-capital-management.mjs

@@ -1,7 +1,7 @@
 import { AXTranslationService } from '@acorex/core/translation';
 import { AXPWorkflowTaskProvider, AXP_WORKFLOW_TASK_PROVIDER } from '@acorex/modules/task-management';
 import { AXPSystemStatuses, AXPStatusProvider, systemStatusToDefinition, AXPSystemStatusType, AXP_STATUS_PROVIDERS, AXP_MENU_PROVIDER } from '@acorex/platform/common';
-import { AXPEntityService, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
+import { AXPEntityService, AXPEntityDefinitionRegistryService, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
 import { AXPCommandExecutor, AXPCommandEventsService, AXPRuntimeModule, provideCommandSetups } from '@acorex/platform/runtime';
 import * as i0 from '@angular/core';
 import { inject, Injectable, DestroyRef, signal, NgModule, Injector } from '@angular/core';
@@ -194,17 +194,39 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.16", ngImpo
                 }]
         }] });
 
+//#region ----   Imports   ----
+//#endregion
+/**
+ * Leave Request Task Provider
+ *
+ * Integrates with workflow engine to show leave request tasks from work items.
+ * Uses work items created by workflow engine for human-task activities.
+ *
+ * Architecture:
+ * - Queries work items filtered by entityRefType = 'HumanCapitalManagement.LeaveRequest'
+ * - Loads related entity data from entityRefId
+ * - Maps work item status to task board status
+ * - Provides actions based on workflow activity definitions
+ */
 class AXMLeaveRequestTaskProvider extends AXPWorkflowTaskProvider {
     constructor() {
+        //#region ----   Services & Dependencies   ----
         super(...arguments);
         this.entityService = inject(AXPEntityService);
+        this.entityRegistry = inject(AXPEntityDefinitionRegistryService);
+        this.workItemData = this.entityService
+            .withEntity('WorkflowManagement', 'WorkItem')
+            .data();
         this.leaveRequestData = this.entityService
             .withEntity(RootConfig.module.name, RootConfig.entities.leaveRequest.name)
             .data();
         this.commandExecutor = inject(AXPCommandExecutor);
         this.translationService = inject(AXTranslationService);
         this.dialogService = inject(AXPLeaveRequestDialogService);
+        //#endregion
     }
+    //#endregion
+    //#region ----   Provider Metadata   ----
     get name() {
         return 'leave-request';
     }
@@ -214,184 +236,627 @@ class AXMLeaveRequestTaskProvider extends AXPWorkflowTaskProvider {
     get icon() {
         return 'fa-light fa-plane-departure';
     }
+    //#endregion
+    //#region ----   Task Retrieval   ----
+    /**
+     * Get tasks from work items for leave requests.
+     *
+     * Queries work items filtered by:
+     * - entityRefType = 'HumanCapitalManagement.LeaveRequest'
+     * - status (Pending, Claimed, InProgress)
+     * - assignee/claimant (if filter provided)
+     * - date range (if provided)
+     *
+     * Then loads related entity data and maps to task board format.
+     */
     async getTasks(options) {
+        console.log(`[LeaveRequestTaskProvider] 🔍 getTasks called with options:`, {
+            skip: options?.skip,
+            take: options?.take,
+            assigneeIds: options?.assigneeIds,
+            range: options?.range,
+            types: options?.types,
+        });
+        // Build filter for work items
         const baseFilter = { logic: 'and', filters: [] };
-        baseFilter.filters?.push({
-            field: 'statusId',
-            operator: { type: 'equal', negative: true },
-            value: AXPSystemStatuses.Cancelled.name,
+        const entityTypeValue = `${RootConfig.module.name}.${RootConfig.entities.leaveRequest.name}`;
+        const workflowNameValue = 'create-leave-request';
+        console.log(`[LeaveRequestTaskProvider] 📋 Building filters:`, {
+            entityType: entityTypeValue,
+            workflowName: workflowNameValue,
         });
-        // Filter for tasks that OVERLAP with the given date range
-        // A task overlaps if: task.startDate <= range.end AND task.endDate >= range.from
-        if (options?.range?.end) {
-            baseFilter.filters?.push({ field: 'startDate', operator: { type: 'lte' }, value: options.range.end });
+        // Filter by entity type OR workflow instance definitionId
+        // Primary: entityRefType (set after entity creation)
+        // Fallback: instanceId from workflow instances with definitionId = 'create-leave-request'
+        // We'll use OR logic to catch both cases
+        const entityTypeFilter = {
+            field: 'entityRefType',
+            operator: { type: 'equal' },
+            value: entityTypeValue,
+        };
+        // Try to get workflow instance IDs for fallback
+        let workflowInstanceIds = [];
+        try {
+            const workflowInstanceData = this.entityService
+                .withEntity('WorkflowManagement', 'WorkflowInstance')
+                .data();
+            const instances = await workflowInstanceData.query({
+                skip: 0,
+                take: 100,
+                filter: {
+                    logic: 'and',
+                    filters: [
+                        {
+                            field: 'definitionId',
+                            operator: { type: 'equal' },
+                            value: workflowNameValue,
+                        },
+                    ],
+                },
+            });
+            workflowInstanceIds = instances.items.map((inst) => inst.id);
+            console.log(`[LeaveRequestTaskProvider] 🔍 Found ${workflowInstanceIds.length} workflow instances for '${workflowNameValue}'`);
+        }
+        catch (error) {
+            console.warn(`[LeaveRequestTaskProvider] ⚠️ Failed to query workflow instances:`, error);
+        }
+        // Build OR filter: entityRefType OR instanceId in workflowInstanceIds
+        if (workflowInstanceIds.length > 0) {
+            baseFilter.filters?.push({
+                logic: 'or',
+                filters: [
+                    entityTypeFilter,
+                    {
+                        field: 'instanceId',
+                        operator: { type: 'in' },
+                        value: workflowInstanceIds,
+                    },
+                ],
+            });
         }
-        if (options?.range?.from) {
-            baseFilter.filters?.push({ field: 'endDate', operator: { type: 'gte' }, value: options.range.from });
+        else {
+            // Only use entityRefType if no workflow instances found
+            baseFilter.filters?.push(entityTypeFilter);
         }
+        // Filter by status (exclude completed/cancelled)
+        baseFilter.filters?.push({
+            field: 'status',
+            operator: { type: 'in' },
+            value: ['Pending', 'Claimed', 'InProgress'],
+        });
+        // Filter by date range if provided
+        // Work items don't have startDate/endDate directly, but we can filter by createdAt or dueDate
+        // For now, we'll skip date range filtering to ensure work items are found
+        // TODO: Implement proper date range filtering based on entity data (startDate/endDate)
+        // if (options?.range?.from || options?.range?.end) {
+        //   if (options.range.from) {
+        //     baseFilter.filters?.push({
+        //       field: 'createdAt',
+        //       operator: { type: 'gte' as const },
+        //       value: options.range.from,
+        //     });
+        //   }
+        //   
+        //   if (options.range.end) {
+        //     // For end date, we want: dueDate <= end OR dueDate is null
+        //     // This allows work items without dueDate to still appear
+        //     baseFilter.filters?.push({
+        //       logic: 'or',
+        //       filters: [
+        //         {
+        //           field: 'dueDate',
+        //           operator: { type: 'lte' as const },
+        //           value: options.range.end,
+        //         },
+        //         {
+        //           field: 'dueDate',
+        //           operator: { type: 'isNull' as const },
+        //         },
+        //       ],
+        //     });
+        //   }
+        // }
+        // Filter by assignee/claimant
         if (options?.assigneeIds && options.assigneeIds.length > 0) {
-            // Filter by manager (assignee) of the employee requesting leave
             baseFilter.filters?.push({
-                field: 'employee.manager.userId',
-                operator: { type: 'in' },
-                value: options.assigneeIds,
+                logic: 'or',
+                filters: [
+                    {
+                        field: 'assignedUserId',
+                        operator: { type: 'in' },
+                        value: options.assigneeIds,
+                    },
+                    {
+                        field: 'claimedByUserId',
+                        operator: { type: 'in' },
+                        value: options.assigneeIds,
+                    },
+                ],
             });
         }
-        const { items, total } = await this.leaveRequestData.query({
+        console.log(`[LeaveRequestTaskProvider] 🔎 Query filter:`, JSON.stringify(baseFilter, null, 2));
+        // Query work items
+        const { items: workItems, total } = await this.workItemData.query({
             skip: options?.skip ?? 0,
             take: options?.take ?? 20,
             filter: baseFilter,
         });
-        const tasks = items.map((item) => {
-            const statusId = item.statusId ?? item.status?.id ?? AXPSystemStatuses.Pending.name;
-            const statusTitle = item.status?.title ??
-                this.translationService.translateSync(`@human-capital-management:leave-requests.states.${statusId}`);
-            return {
-                id: item.id,
-                title: `${item.employee?.person?.displayName} - ${this.translationService.translateSync(item.leaveType?.title ?? '')}`,
-                description: item.reason ?? '',
-                startDate: item.startDate ?? new Date(),
-                endDate: item.endDate ?? new Date(),
-                // Leave requests are all-day events by default (they span full days)
-                allDay: true,
-                assignee: {
-                    id: item.employee?.userId ?? '',
-                    type: 'user',
-                    fullName: item.employee?.manager?.person?.displayName ?? '',
-                },
-                index: 2,
-                status: { id: statusId, title: statusTitle },
-                priority: this.getPriorityFromStatus(statusId),
-                reporter: {
-                    id: item.employee?.userId ?? item.employeeId,
-                    type: 'user',
-                    fullName: item.employee?.person?.displayName ?? '',
-                },
-                payload: item,
-            };
+        console.log(`[LeaveRequestTaskProvider] 📦 Query result:`, {
+            total,
+            itemsCount: workItems.length,
+            workItems: workItems.map((wi) => ({
+                id: wi.id,
+                title: wi.title,
+                status: wi.status,
+                entityRefType: wi.entityRefType,
+                entityRefId: wi.entityRefId,
+                instanceId: wi.instanceId,
+                instanceDefinitionId: wi.instance?.definitionId,
+                instanceName: wi.instance?.name,
+                activityNodeId: wi.activityNodeId,
+                activityName: wi.activityName,
+                createdAt: wi.createdAt,
+                dueDate: wi.dueDate,
+            })),
         });
+        // Debug: Log if no work items found
+        if (workItems.length === 0) {
+            console.warn(`[LeaveRequestTaskProvider] ⚠️ No work items found!`, {
+                filter: baseFilter,
+                entityTypeValue: `${RootConfig.module.name}.${RootConfig.entities.leaveRequest.name}`,
+                workflowNameValue: 'create-leave-request',
+                suggestion: 'Check if: 1) Workflow was started, 2) Human-task activity exists, 3) Work item was created, 4) entityRefType was set after entity creation',
+            });
+            // Fallback: Try to query all work items to see what we have
+            const allWorkItems = await this.workItemData.query({
+                skip: 0,
+                take: 10,
+                filter: {
+                    logic: 'and',
+                    filters: [
+                        {
+                            field: 'status',
+                            operator: { type: 'in' },
+                            value: ['Pending', 'Claimed', 'InProgress'],
+                        },
+                    ],
+                },
+            });
+            console.log(`[LeaveRequestTaskProvider] 🔍 Fallback: Found ${allWorkItems.items.length} work items total (any entity):`, {
+                workItems: allWorkItems.items.map((wi) => ({
+                    id: wi.id,
+                    title: wi.title,
+                    entityRefType: wi.entityRefType,
+                    entityRefId: wi.entityRefId,
+                    instanceId: wi.instanceId,
+                    status: wi.status,
+                })),
+            });
+        }
+        // Load entity data for each work item and map to tasks
+        const tasks = [];
+        console.log(`[LeaveRequestTaskProvider] 🔄 Processing ${workItems.length} work items...`);
+        for (const workItem of workItems) {
+            try {
+                console.log(`[LeaveRequestTaskProvider] 📝 Processing work item:`, {
+                    id: workItem.id,
+                    title: workItem.title,
+                    entityRefId: workItem.entityRefId,
+                    entityRefType: workItem.entityRefType,
+                    instanceId: workItem.instanceId,
+                    instanceDefinitionId: workItem.instance?.definitionId,
+                });
+                // Load entity data if entityRefId is available
+                let entityData = null;
+                if (workItem.entityRefId) {
+                    try {
+                        console.log(`[LeaveRequestTaskProvider] 🔍 Loading entity data for entityRefId: ${workItem.entityRefId}`);
+                        entityData = await this.leaveRequestData.byKey(workItem.entityRefId);
+                        console.log(`[LeaveRequestTaskProvider] ✅ Entity data loaded:`, {
+                            id: entityData?.id,
+                            employee: entityData?.employee?.person?.displayName,
+                            startDate: entityData?.startDate,
+                            endDate: entityData?.endDate,
+                        });
+                    }
+                    catch (error) {
+                        console.warn(`[LeaveRequestTaskProvider] ⚠️ Failed to load entity data for ${workItem.entityRefId}:`, error);
+                        // Continue without entity data - use work item data only
+                    }
+                }
+                else {
+                    console.log(`[LeaveRequestTaskProvider] ℹ️ No entityRefId, using work item data only`);
+                }
+                // Map work item to task
+                const task = this.mapWorkItemToTask(workItem, entityData);
+                console.log(`[LeaveRequestTaskProvider] ✅ Mapped to task:`, {
+                    id: task.id,
+                    title: task.title,
+                    startDate: task.startDate,
+                    endDate: task.endDate,
+                    status: task.status,
+                });
+                tasks.push(task);
+            }
+            catch (error) {
+                console.error(`[LeaveRequestTaskProvider] ❌ Failed to process work item ${workItem.id}:`, error);
+                // Skip this work item and continue
+            }
+        }
+        console.log(`[LeaveRequestTaskProvider] ✅ Returning ${tasks.length} tasks (total: ${total})`);
         return { items: tasks, total };
     }
+    /**
+     * Map work item to task board task format.
+     */
+    mapWorkItemToTask(workItem, entityData) {
+        // Use entity data if available, otherwise use work item metadata
+        const statusId = entityData?.statusId ?? entityData?.status?.id ?? AXPSystemStatuses.Pending.name;
+        const statusTitle = entityData?.status?.title ??
+            this.translationService.translateSync(`@human-capital-management:leave-requests.states.${statusId}`);
+        // Extract dates from entity data or use work item dates
+        const startDate = entityData?.startDate
+            ? new Date(entityData.startDate)
+            : (workItem.dueDate ? new Date(workItem.dueDate) : new Date());
+        const endDate = entityData?.endDate
+            ? new Date(entityData.endDate)
+            : (workItem.dueDate ? new Date(workItem.dueDate) : new Date());
+        // Build title from entity data or work item
+        let title = workItem.title;
+        if (entityData) {
+            title = `${entityData.employee?.person?.displayName ?? ''} - ${this.translationService.translateSync(entityData.leaveType?.title ?? '')}`.trim();
+            if (!title)
+                title = workItem.title;
+        }
+        // Map work item status to task status
+        const taskStatus = this.mapWorkItemStatusToTaskStatus(workItem.status);
+        return {
+            id: workItem.id, // Use work item ID as task ID
+            title,
+            description: entityData?.reason ?? workItem.description ?? '',
+            startDate,
+            endDate,
+            allDay: true, // Leave requests are all-day events
+            assignee: workItem.assignedUser
+                ? {
+                    id: workItem.assignedUser.id,
+                    type: 'user',
+                    fullName: workItem.assignedUser.displayName,
+                }
+                : workItem.claimedByUser
+                    ? {
+                        id: workItem.claimedByUser.id,
+                        type: 'user',
+                        fullName: workItem.claimedByUser.displayName,
+                    }
+                    : undefined,
+            index: 2,
+            status: taskStatus,
+            priority: this.mapWorkItemPriorityToTaskPriority(workItem.priority),
+            reporter: entityData?.employee
+                ? {
+                    id: entityData.employee.userId ?? entityData.employeeId,
+                    type: 'user',
+                    fullName: entityData.employee.person?.displayName ?? '',
+                }
+                : workItem.createdByUser
+                    ? {
+                        id: workItem.createdByUser.id,
+                        type: 'user',
+                        fullName: workItem.createdByUser.displayName,
+                    }
+                    : {
+                        id: '',
+                        type: 'user',
+                        fullName: '',
+                    },
+            data: {
+                // Store entity data and work item metadata
+                entityData: entityData ?? null,
+                workItem: workItem,
+                workItemId: workItem.id,
+                instanceId: workItem.instanceId,
+                activityNodeId: workItem.activityNodeId,
+                entityRefId: workItem.entityRefId,
+                entityRefType: workItem.entityRefType,
+            }, // Additional metadata for task processing
+        };
+    }
+    /**
+     * Map work item status to task board status.
+     */
+    mapWorkItemStatusToTaskStatus(workItemStatus) {
+        // Map work item status to entity status
+        switch (workItemStatus) {
+            case 'Pending':
+                return {
+                    id: AXPSystemStatuses.Pending.name,
+                    title: this.translationService.translateSync('@human-capital-management:leave-requests.states.pending'),
+                };
+            case 'Claimed':
+            case 'InProgress':
+                return {
+                    id: AXPSystemStatuses.Pending.name, // Still pending from entity perspective
+                    title: this.translationService.translateSync('@human-capital-management:leave-requests.states.pending'),
+                };
+            case 'Completed':
+                return {
+                    id: AXPSystemStatuses.Approved.name, // Completed work item = approved
+                    title: this.translationService.translateSync('@human-capital-management:leave-requests.states.approved'),
+                };
+            case 'Rejected':
+                return {
+                    id: AXPSystemStatuses.Rejected.name,
+                    title: this.translationService.translateSync('@human-capital-management:leave-requests.states.rejected'),
+                };
+            case 'Cancelled':
+                return {
+                    id: AXPSystemStatuses.Cancelled.name,
+                    title: this.translationService.translateSync('@human-capital-management:leave-requests.states.cancelled'),
+                };
+            default:
+                return {
+                    id: AXPSystemStatuses.Pending.name,
+                    title: this.translationService.translateSync('@human-capital-management:leave-requests.states.pending'),
+                };
+        }
+    }
+    /**
+     * Map work item priority to task board priority.
+     */
+    mapWorkItemPriorityToTaskPriority(workItemPriority) {
+        switch (workItemPriority) {
+            case 'Urgent':
+                return 'highest';
+            case 'High':
+                return 'high';
+            case 'Normal':
+                return 'medium';
+            case 'Low':
+                return 'low';
+            default:
+                return 'medium';
+        }
+    }
+    //#endregion
+    //#region ----   Task Updates   ----
+    /**
+     * Update tasks (work items and/or entity data).
+     *
+     * Updates both work item (if task ID is work item ID) and entity data (if entityRefId is available).
+     */
     async updateTasks(tasksToUpdate) {
-        // Update each task in the backend
         const updatedTasks = [];
         for (const task of tasksToUpdate) {
             try {
-                // Build update payload with all changed fields
-                const updatePayload = {};
-                // Update status if present
-                if (task.status?.id) {
-                    const statusId = task.status.id;
-                    updatePayload['statusId'] = statusId;
-                }
-                // Update dates if present
-                if (task.startDate) {
-                    updatePayload['startDate'] = task.startDate;
+                const taskData = task.data;
+                const workItemId = taskData?.workItemId ?? task.id;
+                const entityRefId = taskData?.entityRefId;
+                // Update work item if task ID is work item ID
+                if (workItemId) {
+                    const workItemUpdate = {};
+                    if (task.status?.id) {
+                        // Map task status back to work item status
+                        const workItemStatus = this.mapTaskStatusToWorkItemStatus(String(task.status.id));
+                        if (workItemStatus) {
+                            workItemUpdate['status'] = workItemStatus;
+                        }
+                    }
+                    if (task.assignee?.id) {
+                        workItemUpdate['assignedUserId'] = task.assignee.id;
+                    }
+                    if (Object.keys(workItemUpdate).length > 0) {
+                        await this.workItemData.update(workItemId, workItemUpdate);
+                    }
                 }
-                if (task.endDate) {
-                    updatePayload['endDate'] = task.endDate;
+                // Update entity data if entityRefId is available
+                if (entityRefId) {
+                    const entityUpdate = {};
+                    if (task.status?.id) {
+                        const statusId = task.status.id;
+                        entityUpdate['statusId'] = statusId;
+                    }
+                    if (task.startDate) {
+                        entityUpdate['startDate'] = task.startDate;
+                    }
+                    if (task.endDate) {
+                        entityUpdate['endDate'] = task.endDate;
+                    }
+                    if (Object.keys(entityUpdate).length > 0) {
+                        await this.leaveRequestData.update(entityRefId, entityUpdate);
+                    }
                 }
-                // Only update if there's something to update
-                if (Object.keys(updatePayload).length > 0) {
-                    await this.leaveRequestData.update(String(task.id), updatePayload);
-                }
-                // Return the task as-is (already updated in the task object)
                 updatedTasks.push(task);
             }
             catch (error) {
                 console.error(`[LeaveRequestTaskProvider] Failed to update task ${task.id}:`, error);
-                // Still include the task even if update failed
-                updatedTasks.push(task);
+                updatedTasks.push(task); // Still include the task even if update failed
             }
         }
         return updatedTasks;
     }
+    /**
+     * Map task status to work item status.
+     */
+    mapTaskStatusToWorkItemStatus(taskStatusId) {
+        switch (taskStatusId) {
+            case AXPSystemStatuses.Pending.name:
+                return 'Pending';
+            case AXPSystemStatuses.Approved.name:
+                return 'Completed';
+            case AXPSystemStatuses.Rejected.name:
+                return 'Rejected';
+            case AXPSystemStatuses.Cancelled.name:
+                return 'Cancelled';
+            default:
+                return null;
+        }
+    }
+    //#endregion
+    //#region ----   Command Execution   ----
+    /**
+     * Execute commands on tasks.
+     *
+     * Supports:
+     * - Workflow work item commands (Claim, Complete, Cancel)
+     * - Leave request business commands (Approve, Reject, Cancel)
+     */
     async executeCommand(command) {
         if (!command?.name)
             return { success: true };
-        const leaveRequestId = command.options?.['id'] ?? '';
+        const workItemId = command.options?.['workItemId'] ?? command.options?.['id'] ?? '';
+        const entityRefId = command.options?.['entityRefId'] ?? '';
+        // Handle workflow work item commands
+        if (command.name === 'WorkflowManagement.WorkItem:Claim') {
+            const result = await this.commandExecutor.execute('WorkflowManagement.WorkItem:Claim', {
+                id: workItemId,
+            });
+            return result ?? { success: true };
+        }
+        if (command.name === 'WorkflowManagement.WorkItem:Complete') {
+            const result = await this.commandExecutor.execute('WorkflowManagement.WorkItem:Complete', {
+                id: workItemId,
+                output: command.options?.['output'] ?? {},
+                outcome: command.options?.['outcome'] ?? 'Done',
+            });
+            return result ?? { success: true };
+        }
+        if (command.name === 'WorkflowManagement.WorkItem:Cancel') {
+            const result = await this.commandExecutor.execute('WorkflowManagement.WorkItem:Cancel', {
+                id: workItemId,
+            });
+            return result ?? { success: true };
+        }
+        // Handle leave request business commands (for backward compatibility)
         switch (command.name) {
             case 'approveLeave': {
-                // Show approval dialog
                 const dialogResult = await this.dialogService.showApprovalDialog();
-                // If dialog was cancelled, return early
                 if (dialogResult?.cancelled) {
                     return { success: false };
                 }
-                // Execute the command - use fallback pattern like JSA
+                // Try to complete work item if available, otherwise use entity command
+                if (workItemId) {
+                    const result = await this.commandExecutor.execute('WorkflowManagement.WorkItem:Complete', {
+                        id: workItemId,
+                        output: { reason: dialogResult?.reason, note: dialogResult?.note },
+                        outcome: 'Approved',
+                    });
+                    return result ?? { success: true };
+                }
+                // Fallback to entity command
                 const result = await this.commandExecutor.execute('HumanCapitalManagement.LeaveRequest:Approve', {
-                    id: leaveRequestId,
+                    id: entityRefId || workItemId,
                     reason: dialogResult?.reason,
                     note: dialogResult?.note,
                 });
-                // Return result if exists, otherwise default to success (command might not be registered yet)
                 return result ?? { success: true };
             }
             case 'rejectLeave': {
-                // Show rejection dialog
                 const dialogResult = await this.dialogService.showRejectionDialog();
-                // If dialog was cancelled, return early
                 if (dialogResult?.cancelled) {
                     return { success: false };
                 }
-                // Execute the command - use fallback pattern like JSA
+                // Try to complete work item if available, otherwise use entity command
+                if (workItemId) {
+                    const result = await this.commandExecutor.execute('WorkflowManagement.WorkItem:Complete', {
+                        id: workItemId,
+                        output: { reason: dialogResult?.reason, note: dialogResult?.note },
+                        outcome: 'Rejected',
+                    });
+                    return result ?? { success: true };
+                }
+                // Fallback to entity command
                 const result = await this.commandExecutor.execute('HumanCapitalManagement.LeaveRequest:Reject', {
-                    id: leaveRequestId,
+                    id: entityRefId || workItemId,
                     reason: dialogResult?.reason,
                     note: dialogResult?.note,
                 });
-                // Return result if exists, otherwise default to success (command might not be registered yet)
                 return result ?? { success: true };
             }
             case 'cancelLeave': {
-                // Show cancellation dialog
                 const dialogResult = await this.dialogService.showCancellationDialog();
-                // If dialog was cancelled, return early
                 if (dialogResult?.cancelled) {
                     return { success: false };
                 }
-                // Execute the command - use fallback pattern like JSA
+                // Try to cancel work item if available, otherwise use entity command
+                if (workItemId) {
+                    const result = await this.commandExecutor.execute('WorkflowManagement.WorkItem:Cancel', {
+                        id: workItemId,
+                    });
+                    return result ?? { success: true };
+                }
+                // Fallback to entity command
                 const result = await this.commandExecutor.execute('HumanCapitalManagement.LeaveRequest:Cancel', {
-                    id: leaveRequestId,
+                    id: entityRefId || workItemId,
                     reason: dialogResult?.reason,
                     note: dialogResult?.note,
                 });
-                // Return result if exists, otherwise default to success (command might not be registered yet)
                 return result ?? { success: true };
             }
         }
         return { success: true };
     }
+    //#endregion
+    //#region ----   Actions & Statuses   ----
+    /**
+     * Get available actions for a task.
+     *
+     * Provides actions based on work item status and workflow activity.
+     */
     async getActions(task) {
         const actions = [];
-        // Add approve action for pending requests
-        if (task?.status?.id === AXPSystemStatuses.Pending.name || task?.status?.id === AXPSystemStatuses.Rejected.name) {
+        if (!task)
+            return actions;
+        const taskData = task.data;
+        const workItemId = taskData?.workItemId ?? task.id;
+        const entityRefId = taskData?.entityRefId;
+        // Add workflow work item actions
+        if (task.status?.id === AXPSystemStatuses.Pending.name) {
+            // Claim action (if not already claimed)
+            actions.push({
+                name: 'WorkflowManagement.WorkItem:Claim',
+                title: this.translationService.translateSync('@workflow-management:work-items.actions.claim.title'),
+                icon: 'fa-light fa-hand',
+                color: 'primary',
+                command: {
+                    name: 'WorkflowManagement.WorkItem:Claim',
+                    options: { id: workItemId, workItemId },
+                },
+            });
+            // Complete action (with approve/reject outcomes)
             actions.push({
                 name: 'approveLeave',
                 title: this.translationService.translateSync('@general:actions.approve.title'),
                 icon: 'fa-light fa-check',
                 color: 'success',
-                command: { name: 'approveLeave', options: { id: task?.id ?? '' } },
+                command: {
+                    name: 'approveLeave',
+                    options: { id: entityRefId || workItemId, workItemId, entityRefId },
+                },
             });
-        }
-        // Add reject action for pending or approved requests
-        if (task?.status?.id === AXPSystemStatuses.Pending.name || task?.status?.id === AXPSystemStatuses.Approved.name) {
             actions.push({
                 name: 'rejectLeave',
                 title: this.translationService.translateSync('@general:actions.reject.title'),
                 icon: 'fa-light fa-xmark',
                 color: 'danger',
-                command: { name: 'rejectLeave', options: { id: task?.id ?? '' } },
+                command: {
+                    name: 'rejectLeave',
+                    options: { id: entityRefId || workItemId, workItemId, entityRefId },
+                },
             });
         }
-        // Add cancel action for pending or approved requests
-        if (task?.status?.id === AXPSystemStatuses.Pending.name || task?.status?.id === AXPSystemStatuses.Approved.name) {
+        // Add cancel action
+        if (task.status?.id === AXPSystemStatuses.Pending.name ||
+            task.status?.id === AXPSystemStatuses.Approved.name) {
             actions.push({
-                name: 'rejectLeave',
+                name: 'cancelLeave',
                 title: this.translationService.translateSync('@general:actions.cancel.title'),
                 icon: 'fa-light fa-ban',
                 color: 'secondary',
-                command: { name: 'cancelLeave', options: { id: task?.id ?? '' } },
+                command: {
+                    name: 'cancelLeave',
+                    options: { id: entityRefId || workItemId, workItemId, entityRefId },
+                },
             });
         }
         return actions;
@@ -427,18 +892,8 @@ class AXMLeaveRequestTaskProvider extends AXPWorkflowTaskProvider {
             },
         ];
     }
-    getPriorityFromStatus(statusId) {
-        switch (statusId) {
-            case AXPSystemStatuses.Pending.name:
-                return 'medium';
-            case AXPSystemStatuses.Approved.name:
-                return 'lowest';
-            case AXPSystemStatuses.Rejected.name:
-                return 'high';
-            default:
-                return 'medium';
-        }
-    }
+    //#endregion
+    //#region ----   Component   ----
     getComponent() {
         return () => import('./acorex-modules-human-capital-management-leave-request-task-popover.component-yGvT9kSL.mjs').then((m) => m.AXMLeaveRequestTaskPopoverComponent);
     }
@@ -924,7 +1379,7 @@ class AXMHumanCapitalModuleEntityProvider {
                 case RootConfig.entities.leaveType.name:
                     return (await import('./acorex-modules-human-capital-management-leave-type.entity-CY81Nohl.mjs')).factory();
                 case RootConfig.entities.leaveRequest.name:
-                    return (await import('./acorex-modules-human-capital-management-leave-request.entity-CITYAroH.mjs')).factory();
+                    return (await import('./acorex-modules-human-capital-management-leave-request.entity-Dn2LLbuq.mjs')).factory();
             }
         }
         return null;