@acorex-platform/module-background-job-management-client 0.0.30 → 0.0.32

package/fesm2022/acorex-platform-module-background-job-management-client.mjs

@@ -1,15 +1,20 @@
-import { AXP_BACKGROUND_JOB_SCHEDULE_STATUS_DEFINITION_KEY, AXP_BACKGROUND_JOB_SCHEDULE_STATUS_ACTIVE, AXP_BACKGROUND_JOB_STATUS_DEFINITION_KEY, AXP_BACKGROUND_JOB_STATUS_CREATED, AXPBackgroundJobCommandKeys } from '@acorex-platform/framework-shared/background-job';
-import { AXPSessionService, AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/auth';
-import { AXP_STATUS_PROVIDERS, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/common';
-import { AXP_MODULE_MANIFEST_PROVIDER } from '@acorex-platform/framework-client/core';
-import { provideCommandSetups } from '@acorex-platform/framework-client/runtime';
+import { AXP_BACKGROUND_JOB_SCHEDULE_STATUS_DEFINITION_KEY, AXP_BACKGROUND_JOB_SCHEDULE_STATUS_ACTIVE, AXP_BACKGROUND_JOB_STATUS_DEFINITION_KEY, AXP_BACKGROUND_JOB_STATUS_CREATED, AXPBackgroundJobQueryKeys, isBackgroundJobTerminal, AXPBackgroundJobCommandKeys } from '@acorex-platform/framework-shared/background-job';
+import { AXPSessionService, AXPSessionStatus, AXP_PERMISSION_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/auth';
+import { axpCoerceBackgroundOperationDate, axpBackgroundOperationFailurePolicy, axpBackgroundOperationCapabilities, AXPBackgroundOperationProvider, AXP_BACKGROUND_OPERATION_PROVIDERS, AXP_STATUS_PROVIDERS, AXP_MENU_PROVIDER, AXP_SETTING_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/common';
+import { provideAppStartUpTask, AXP_APP_STARTUP_PRIORITY, AXP_MODULE_MANIFEST_PROVIDER } from '@acorex-platform/framework-client/core';
+import { AXPQueryService, provideCommandSetups } from '@acorex-platform/framework-client/runtime';
+import { AXPWidgetCoreModule, AXP_WIDGET_DEFINITION_PROVIDER } from '@acorex-platform/framework-client/layout/widget-core';
 import * as i0 from '@angular/core';
-import { inject, Injectable, NgModule } from '@angular/core';
-import { AXPStatusProvider, AXPWidgetsList } from '@acorex-platform/framework-shared/core';
-import { RootConfig, AXPAdministrationPermissionKeys, AXPBackgroundJobManagementMenuKeys, AXPBackgroundJobManagementSettings } from '@acorex-platform/module-background-job-management-client/contracts';
+import { Injectable, inject, DestroyRef, signal, computed, NgModule } from '@angular/core';
+import { BACKGROUND_JOB_SOURCE_COLUMN_WIDGET, RootConfig, AXPAdministrationPermissionKeys, AXPBackgroundJobManagementMenuKeys, AXPBackgroundJobManagementSettings } from '@acorex-platform/module-background-job-management-client/contracts';
+import { AXPWidgetGroupEnum } from '@acorex-platform/framework-shared/widget-core';
+import { AXPStatusProvider, runtimeQueryCollectionData, AXPWidgetsList } from '@acorex-platform/framework-shared/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { filter } from 'rxjs/operators';
+import { Subject, distinctUntilChanged, timer, switchMap, EMPTY, firstValueFrom } from 'rxjs';
+import { AXPRealtimeConnectionService, AXPRealtimeDispatcherService, AXP_REALTIME_TOPIC_BACKGROUND_JOB_TRAY_REFRESH } from '@acorex-platform/framework-client/realtime';
 import { AXPCommonMenuKeys, AXPCommonPermissionGroupKeys } from '@acorex-platform/module-common-client/contracts';
 import { AXPEntityService } from '@acorex-platform/framework-client/layout/entity';
-import { firstValueFrom } from 'rxjs';
 
 //#region ---- Client port ----
 /**
@@ -20,6 +25,37 @@ class AXPBackgroundJobManagementClient {
 }
 //#endregion
 
+//#region ----- Imports -----
+//#endregion
+//#region ----- Widget -----
+const BackgroundJobSourceColumnWidget = {
+    name: BACKGROUND_JOB_SOURCE_COLUMN_WIDGET,
+    title: '@background-job-management:jobs.entities.background-job.fields.source.title',
+    icon: 'fa-light fa-user',
+    groups: [AXPWidgetGroupEnum.BaseWidget],
+    type: 'editor',
+    components: {
+        column: {
+            component: () => import('./acorex-platform-module-background-job-management-client-background-job-source-column.component-JzU8l_7q.mjs').then((c) => c.BackgroundJobSourceColumnComponent),
+        },
+    },
+};
+//#endregion
+
+//#endregion
+//#region ----- Widgets provider -----
+const BACKGROUND_JOB_WIDGETS = [BackgroundJobSourceColumnWidget];
+class AXMBackgroundJobManagementWidgetsProvider {
+    getWidgets() {
+        return BACKGROUND_JOB_WIDGETS;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMBackgroundJobManagementWidgetsProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMBackgroundJobManagementWidgetsProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMBackgroundJobManagementWidgetsProvider, decorators: [{
+            type: Injectable
+        }] });
+
 const I18N$1 = '@background-job-management:schedules.entities.background-job-schedule';
 //#region ---- Job schedule status provider ----
 class AXMBackgroundJobScheduleStatusProvider extends AXPStatusProvider {
@@ -138,6 +174,472 @@ class AXMBackgroundJobStatusProvider extends AXPStatusProvider {
 }
 //#endregion
 
+//#region ----- Status mapping -----
+const ACTIVE_JOB_STATUSES = new Set([
+    'created',
+    'scheduled',
+    'queued',
+    'running',
+    'paused',
+]);
+function mapBackgroundJobStatusToOperationStatus(status) {
+    switch (status) {
+        case 'running':
+            return 'running';
+        case 'paused':
+            return 'paused';
+        case 'completed':
+            return 'completed';
+        case 'failed':
+        case 'dead-lettered':
+            return 'failed';
+        case 'cancelled':
+            return 'cancelled';
+        case 'created':
+        case 'scheduled':
+        case 'queued':
+        default:
+            return 'queued';
+    }
+}
+//#endregion
+//#region ----- Job → tray operation -----
+function mapBackgroundJobToTrayOperation(job) {
+    const status = mapBackgroundJobStatusToOperationStatus(job.status);
+    const isActive = ACTIVE_JOB_STATUSES.has(job.status);
+    const capabilities = job.capabilities ?? {};
+    const createdAt = axpCoerceBackgroundOperationDate(job.createdAt) ?? new Date();
+    return {
+        id: job.id,
+        providerKey: job.providerKey,
+        title: job.title,
+        status,
+        progress: job.progress,
+        statusText: job.statusText,
+        currentStep: job.currentStep,
+        createdAt,
+        startedAt: axpCoerceBackgroundOperationDate(job.firstStartedAt) ??
+            axpCoerceBackgroundOperationDate(job.executedAt) ??
+            undefined,
+        completedAt: axpCoerceBackgroundOperationDate(job.completedAt) ?? undefined,
+        capabilities: axpBackgroundOperationCapabilities({
+            cancellable: isActive &&
+                (capabilities.supportsCooperativeCancellation === true || capabilities.canCancelQueued === true),
+            pausable: isActive && capabilities.supportsCooperativePause === true,
+            resumable: status === 'paused' && capabilities.supportsCooperativePause === true,
+            retryable: status === 'failed',
+            supportsProgress: capabilities.supportsProgress === true || typeof job.progress === 'number',
+            supportsEstimate: capabilities.supportsEstimate === true,
+            clickable: capabilities.clickable === true,
+            keepInTrayAfterComplete: capabilities.keepInTrayAfterComplete === true,
+            notifyOnComplete: capabilities.notifyOnComplete !== false,
+            notifyOnFailed: capabilities.notifyOnFailed !== false,
+        }),
+        failurePolicy: axpBackgroundOperationFailurePolicy({
+            maxRetries: job.maxAttempts,
+            retryCount: Math.max(0, job.currentAttempt - 1),
+        }),
+        error: job.result?.message
+            ? {
+                message: job.result.message,
+                code: typeof job.result.data?.['code'] === 'string' ? job.result.data['code'] : undefined,
+            }
+            : undefined,
+        data: {
+            jobId: job.id,
+            providerKey: job.providerKey,
+            command: job.command,
+            payload: job.command?.payload,
+            reportRequestId: typeof job.command?.payload?.['reportRequestId'] === 'string'
+                ? job.command.payload['reportRequestId']
+                : undefined,
+        },
+    };
+}
+//#endregion
+
+//#endregion
+//#region ----- Tray realtime events -----
+class BackgroundJobTrayRealtimeService {
+    constructor() {
+        this.changedSubject = new Subject();
+        this.changed$ = this.changedSubject.asObservable();
+    }
+    notifyChanged(payload) {
+        this.changedSubject.next({ payload });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: BackgroundJobTrayRealtimeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: BackgroundJobTrayRealtimeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: BackgroundJobTrayRealtimeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+//#region ----- Constants -----
+/** Safety net while a job is active if a realtime tick was missed. */
+const ACTIVE_JOB_WATCHDOG_MS = 30_000;
+/** Coalesce consecutive full-list fetches (e.g. create + early progress before local row exists). */
+const FULL_REFRESH_DEBOUNCE_MS = 250;
+const TERMINAL_STATUSES = new Set(['completed', 'failed', 'cancelled', 'dead-lettered']);
+//#endregion
+//#region ----- Tray sync service -----
+class BackgroundJobTraySyncService {
+    constructor() {
+        //#region ----- Dependencies -----
+        this.queryService = inject(AXPQueryService);
+        this.sessionService = inject(AXPSessionService);
+        this.client = inject(AXPBackgroundJobManagementClient);
+        this.destroyRef = inject(DestroyRef);
+        this.trayRealtime = inject(BackgroundJobTrayRealtimeService, { optional: true });
+        //#endregion
+        //#region ----- State -----
+        this.jobs = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "jobs" }] : /* istanbul ignore next */ []));
+        this.started = false;
+        this.refreshGeneration = 0;
+        this.refreshInFlight = false;
+        this.refreshQueued = false;
+        this.watchdogTimer = null;
+        this.fullRefreshTimer = null;
+        this.operations = computed(() => this.jobs().map((job) => mapBackgroundJobToTrayOperation(job)), /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "operations" }] : /* istanbul ignore next */ []));
+    }
+    //#endregion
+    //#region ----- Lifecycle -----
+    start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        this.destroyRef.onDestroy(() => {
+            this.clearActiveWatchdog();
+            this.clearFullRefreshTimer();
+        });
+        this.sessionService.status$
+            .pipe(filter((status) => status === AXPSessionStatus.Authorized), takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => {
+            void this.refresh();
+        });
+        this.sessionService.status$
+            .pipe(filter((status) => status !== AXPSessionStatus.Authorized), takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => {
+            this.clearActiveWatchdog();
+            this.clearFullRefreshTimer();
+            this.jobs.set([]);
+        });
+        this.trayRealtime?.changed$.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(({ payload }) => {
+            this.applyRealtimePayload(payload);
+        });
+        if (this.sessionService.isAuthorized) {
+            void this.refresh();
+        }
+    }
+    async refresh() {
+        this.clearFullRefreshTimer();
+        if (this.refreshInFlight) {
+            this.refreshQueued = true;
+            return;
+        }
+        this.refreshInFlight = true;
+        const generation = ++this.refreshGeneration;
+        try {
+            if (!this.sessionService.isAuthorized) {
+                if (generation === this.refreshGeneration) {
+                    this.clearActiveWatchdog();
+                    this.jobs.set([]);
+                }
+                return;
+            }
+            try {
+                const result = await this.queryService.fetch(AXPBackgroundJobQueryKeys.JobListActiveForTray, { take: 100 });
+                if (generation !== this.refreshGeneration) {
+                    return;
+                }
+                const items = runtimeQueryCollectionData(result)?.items ?? [];
+                this.jobs.set(items);
+                this.armActiveWatchdog();
+            }
+            catch {
+                // Keep the last known tray snapshot when sync fails transiently.
+                if (generation === this.refreshGeneration) {
+                    this.armActiveWatchdog();
+                }
+            }
+        }
+        finally {
+            this.refreshInFlight = false;
+            if (this.refreshQueued) {
+                this.refreshQueued = false;
+                if (this.sessionService.isAuthorized) {
+                    void this.refresh();
+                }
+            }
+        }
+    }
+    async dismissJobs(jobIds) {
+        const ids = [...new Set(jobIds.map((id) => id?.trim()).filter(Boolean))];
+        if (ids.length === 0) {
+            return;
+        }
+        // Optimistic hide; realtime `dismissed` keeps other tabs in sync without a list refetch.
+        this.removeJobs(ids);
+        await this.client.dismissJobs(ids);
+    }
+    //#endregion
+    //#region ----- Private helpers -----
+    applyRealtimePayload(payload) {
+        if (!this.sessionService.isAuthorized) {
+            return;
+        }
+        const jobId = payload.jobId?.trim();
+        if (!jobId) {
+            this.scheduleFullRefresh();
+            return;
+        }
+        if (payload.op === 'dismissed' || payload.trayDismissedAt) {
+            this.removeJobs([jobId]);
+            return;
+        }
+        if (payload.op === 'created') {
+            // New jobs need the full row (title, capabilities, command payload).
+            this.scheduleFullRefresh();
+            return;
+        }
+        const existing = this.jobs().find((job) => job.id === jobId);
+        if (!existing) {
+            this.scheduleFullRefresh();
+            return;
+        }
+        const nextStatus = (payload.status?.trim() || existing.status);
+        const keepInTray = payload.keepInTrayAfterComplete === true || existing.capabilities?.keepInTrayAfterComplete === true;
+        if (isBackgroundJobTerminal(nextStatus) && !keepInTray) {
+            this.removeJobs([jobId]);
+            return;
+        }
+        this.jobs.update((current) => current.map((job) => {
+            if (job.id !== jobId) {
+                return job;
+            }
+            return {
+                ...job,
+                status: nextStatus,
+                progress: typeof payload.progress === 'number' ? payload.progress : job.progress,
+                statusText: payload.statusText ?? job.statusText,
+                currentStep: payload.currentStep ?? job.currentStep,
+                capabilities: {
+                    ...(job.capabilities ?? {}),
+                    supportsProgress: job.capabilities?.supportsProgress === true ||
+                        payload.supportsProgress === true ||
+                        typeof payload.progress === 'number',
+                },
+                completedAt: payload.completedAt ??
+                    (TERMINAL_STATUSES.has(nextStatus) ? job.completedAt ?? new Date().toISOString() : job.completedAt),
+            };
+        }));
+        this.armActiveWatchdog();
+    }
+    scheduleFullRefresh() {
+        this.clearFullRefreshTimer();
+        this.fullRefreshTimer = setTimeout(() => {
+            this.fullRefreshTimer = null;
+            void this.refresh();
+        }, FULL_REFRESH_DEBOUNCE_MS);
+    }
+    clearFullRefreshTimer() {
+        if (!this.fullRefreshTimer) {
+            return;
+        }
+        clearTimeout(this.fullRefreshTimer);
+        this.fullRefreshTimer = null;
+    }
+    removeJobs(jobIds) {
+        const idSet = new Set(jobIds);
+        this.jobs.update((current) => current.filter((job) => !idSet.has(job.id)));
+        this.armActiveWatchdog();
+    }
+    hasActiveTrayJob() {
+        return this.jobs().some((job) => !isBackgroundJobTerminal(job.status));
+    }
+    armActiveWatchdog() {
+        this.clearActiveWatchdog();
+        if (!this.sessionService.isAuthorized || !this.hasActiveTrayJob()) {
+            return;
+        }
+        this.watchdogTimer = setTimeout(() => {
+            this.watchdogTimer = null;
+            void this.refresh();
+        }, ACTIVE_JOB_WATCHDOG_MS);
+    }
+    clearActiveWatchdog() {
+        if (!this.watchdogTimer) {
+            return;
+        }
+        clearTimeout(this.watchdogTimer);
+        this.watchdogTimer = null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: BackgroundJobTraySyncService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: BackgroundJobTraySyncService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: BackgroundJobTraySyncService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+//#region ----- Tray operation provider -----
+class BackgroundJobTrayOperationProvider extends AXPBackgroundOperationProvider {
+    constructor() {
+        super(...arguments);
+        this.key = 'background-job';
+        this.sync = inject(BackgroundJobTraySyncService);
+        this.client = inject(AXPBackgroundJobManagementClient);
+        this.operations = this.sync.operations;
+    }
+    async create(_request) {
+        throw new Error('Background jobs are created on the server.');
+    }
+    async cancel(operationId) {
+        await this.client.cancelJob(operationId);
+        await this.sync.refresh();
+    }
+    async pause(_operationId) {
+        throw new Error('Pause is not supported from the tray yet.');
+    }
+    async resume(_operationId) {
+        throw new Error('Resume is not supported from the tray yet.');
+    }
+    async retry(operationId) {
+        await this.client.retryJob(operationId);
+        await this.sync.refresh();
+    }
+    async dismiss(operationId) {
+        await this.sync.dismissJobs([operationId]);
+    }
+    async dismissMany(operationIds) {
+        await this.sync.dismissJobs(operationIds);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: BackgroundJobTrayOperationProvider, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: BackgroundJobTrayOperationProvider }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: BackgroundJobTrayOperationProvider, decorators: [{
+            type: Injectable
+        }] });
+
+//#region ----- Constants -----
+const POLL_INTERVAL_MS = 60_000;
+const RECONNECT_REFRESH_DELAY_MS = 250;
+//#endregion
+//#region ----- Tray fallback sync -----
+/**
+ * Keeps the footer tray fresh when Socket.IO is down: poll while disconnected,
+ * refresh on reconnect and when the tab becomes visible again.
+ */
+function provideBackgroundJobTrayFallbackSync() {
+    return [
+        provideAppStartUpTask(() => {
+            const sync = inject(BackgroundJobTraySyncService);
+            const sessionService = inject(AXPSessionService);
+            const connection = inject(AXPRealtimeConnectionService, { optional: true });
+            const destroyRef = inject(DestroyRef);
+            const refreshIfAuthorized = () => {
+                if (sessionService.isReadyForAppScopedApi) {
+                    void sync.refresh();
+                }
+            };
+            return {
+                name: 'background-job-tray-fallback-sync',
+                priority: AXP_APP_STARTUP_PRIORITY.realtimeSubscriptions,
+                run: async () => {
+                    if (!connection) {
+                        return;
+                    }
+                    let wasConnected = connection.isSocketConnected();
+                    connection.connectionStatus$
+                        .pipe(distinctUntilChanged(), takeUntilDestroyed(destroyRef))
+                        .subscribe((status) => {
+                        const connected = status === 'connected';
+                        if (connected && !wasConnected) {
+                            timer(RECONNECT_REFRESH_DELAY_MS)
+                                .pipe(takeUntilDestroyed(destroyRef))
+                                .subscribe(() => {
+                                refreshIfAuthorized();
+                            });
+                        }
+                        wasConnected = connected;
+                    });
+                    connection.connectionStatus$
+                        .pipe(distinctUntilChanged(), switchMap((status) => {
+                        if (status === 'connected') {
+                            return EMPTY;
+                        }
+                        return timer(POLL_INTERVAL_MS, POLL_INTERVAL_MS);
+                    }), takeUntilDestroyed(destroyRef))
+                        .subscribe(() => {
+                        refreshIfAuthorized();
+                    });
+                    document.addEventListener('visibilitychange', () => {
+                        if (document.visibilityState === 'visible') {
+                            refreshIfAuthorized();
+                        }
+                    }, { passive: true });
+                },
+            };
+        }),
+    ];
+}
+//#endregion
+
+//#region ----- Tray realtime topic handler -----
+function provideBackgroundJobTrayRealtimeHandlers() {
+    return [
+        provideAppStartUpTask(() => {
+            const dispatcher = inject(AXPRealtimeDispatcherService, { optional: true });
+            const trayRealtime = inject(BackgroundJobTrayRealtimeService);
+            return {
+                name: 'background-job-tray-realtime-handlers',
+                priority: AXP_APP_STARTUP_PRIORITY.realtimeHandlers,
+                run: async () => {
+                    dispatcher?.register({
+                        topic: AXP_REALTIME_TOPIC_BACKGROUND_JOB_TRAY_REFRESH,
+                        handle: (envelope) => {
+                            const payload = (envelope.payload ?? {});
+                            trayRealtime.notifyChanged(payload);
+                        },
+                    });
+                },
+            };
+        }),
+    ];
+}
+//#endregion
+
+//#region ----- Tray providers -----
+function provideBackgroundJobTray() {
+    return [
+        BackgroundJobTrayOperationProvider,
+        {
+            provide: AXP_BACKGROUND_OPERATION_PROVIDERS,
+            useExisting: BackgroundJobTrayOperationProvider,
+            multi: true,
+        },
+        ...provideBackgroundJobTrayRealtimeHandlers(),
+        ...provideBackgroundJobTrayFallbackSync(),
+        provideAppStartUpTask(() => {
+            const sync = inject(BackgroundJobTraySyncService);
+            return {
+                name: 'background-job-tray-sync',
+                priority: AXP_APP_STARTUP_PRIORITY.realtimeHandlers,
+                run: async () => {
+                    sync.start();
+                },
+            };
+        }),
+    ];
+}
+//#endregion
+
 /** Background Job Management module manifest. */
 const BackgroundJobManagementManifest = {
     name: RootConfig.module.name,
@@ -308,20 +810,38 @@ class AXMBackgroundJobManagementSettingProvider {
 
 class AXMBackgroundJobManagementModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMBackgroundJobManagementModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXMBackgroundJobManagementModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "22.0.8", ngImport: i0, type: AXMBackgroundJobManagementModule, imports: [AXPWidgetCoreModule] }); }
     static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMBackgroundJobManagementModule, providers: [
+            {
+                provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                useClass: AXMBackgroundJobManagementWidgetsProvider,
+                multi: true,
+            },
+            ...provideBackgroundJobTray(),
             provideCommandSetups([
                 {
                     key: AXPBackgroundJobCommandKeys.JobCancel,
-                    command: () => import('./acorex-platform-module-background-job-management-client-cancel-background-job.command-OZPzjIow.mjs').then((c) => c.CancelBackgroundJobCommand),
+                    command: () => import('./acorex-platform-module-background-job-management-client-cancel-background-job.command-BHCWX1c1.mjs').then((c) => c.CancelBackgroundJobCommand),
                 },
                 {
                     key: AXPBackgroundJobCommandKeys.JobRetry,
-                    command: () => import('./acorex-platform-module-background-job-management-client-retry-background-job.command-BdJ_PC_y.mjs').then((c) => c.RetryBackgroundJobCommand),
+                    command: () => import('./acorex-platform-module-background-job-management-client-retry-background-job.command-BBEAc_i7.mjs').then((c) => c.RetryBackgroundJobCommand),
+                },
+                {
+                    key: AXPBackgroundJobCommandKeys.JobReplayDeadLetter,
+                    command: () => import('./acorex-platform-module-background-job-management-client-replay-dead-letter.command-BM4NYBxr.mjs').then((c) => c.ReplayDeadLetterBackgroundJobCommand),
+                },
+                {
+                    key: AXPBackgroundJobCommandKeys.TrayExecuteClick,
+                    command: () => import('./acorex-platform-module-background-job-management-client-tray-execute-click.command-CEVhvrDQ.mjs').then((c) => c.BackgroundJobTrayExecuteClickCommand),
+                },
+                {
+                    key: AXPBackgroundJobCommandKeys.TrayRunAction,
+                    command: () => import('./acorex-platform-module-background-job-management-client-tray-run-action.command-B9SFMGxf.mjs').then((c) => c.BackgroundJobTrayRunActionCommand),
                 },
                 {
                     key: AXPBackgroundJobCommandKeys.ScheduleRunNow,
-                    command: () => import('./acorex-platform-module-background-job-management-client-run-schedule-now.command-orzJ7ZmD.mjs').then((c) => c.RunScheduleNowCommand),
+                    command: () => import('./acorex-platform-module-background-job-management-client-run-schedule-now.command-5RV6hAnH.mjs').then((c) => c.RunScheduleNowCommand),
                 },
             ]),
             {
@@ -354,24 +874,43 @@ class AXMBackgroundJobManagementModule {
                 useValue: BackgroundJobManagementManifest,
                 multi: true,
             },
-        ] }); }
+        ], imports: [AXPWidgetCoreModule] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: AXMBackgroundJobManagementModule, decorators: [{
             type: NgModule,
             args: [{
+                    imports: [AXPWidgetCoreModule],
                     providers: [
+                        {
+                            provide: AXP_WIDGET_DEFINITION_PROVIDER,
+                            useClass: AXMBackgroundJobManagementWidgetsProvider,
+                            multi: true,
+                        },
+                        ...provideBackgroundJobTray(),
                         provideCommandSetups([
                             {
                                 key: AXPBackgroundJobCommandKeys.JobCancel,
-                                command: () => import('./acorex-platform-module-background-job-management-client-cancel-background-job.command-OZPzjIow.mjs').then((c) => c.CancelBackgroundJobCommand),
+                                command: () => import('./acorex-platform-module-background-job-management-client-cancel-background-job.command-BHCWX1c1.mjs').then((c) => c.CancelBackgroundJobCommand),
                             },
                             {
                                 key: AXPBackgroundJobCommandKeys.JobRetry,
-                                command: () => import('./acorex-platform-module-background-job-management-client-retry-background-job.command-BdJ_PC_y.mjs').then((c) => c.RetryBackgroundJobCommand),
+                                command: () => import('./acorex-platform-module-background-job-management-client-retry-background-job.command-BBEAc_i7.mjs').then((c) => c.RetryBackgroundJobCommand),
+                            },
+                            {
+                                key: AXPBackgroundJobCommandKeys.JobReplayDeadLetter,
+                                command: () => import('./acorex-platform-module-background-job-management-client-replay-dead-letter.command-BM4NYBxr.mjs').then((c) => c.ReplayDeadLetterBackgroundJobCommand),
+                            },
+                            {
+                                key: AXPBackgroundJobCommandKeys.TrayExecuteClick,
+                                command: () => import('./acorex-platform-module-background-job-management-client-tray-execute-click.command-CEVhvrDQ.mjs').then((c) => c.BackgroundJobTrayExecuteClickCommand),
+                            },
+                            {
+                                key: AXPBackgroundJobCommandKeys.TrayRunAction,
+                                command: () => import('./acorex-platform-module-background-job-management-client-tray-run-action.command-B9SFMGxf.mjs').then((c) => c.BackgroundJobTrayRunActionCommand),
                             },
                             {
                                 key: AXPBackgroundJobCommandKeys.ScheduleRunNow,
-                                command: () => import('./acorex-platform-module-background-job-management-client-run-schedule-now.command-orzJ7ZmD.mjs').then((c) => c.RunScheduleNowCommand),
+                                command: () => import('./acorex-platform-module-background-job-management-client-run-schedule-now.command-5RV6hAnH.mjs').then((c) => c.RunScheduleNowCommand),
                             },
                         ]),
                         {