@alfresco/adf-process-services-cloud 8.1.0-15714928883 → 8.1.0-15782677066

package/esm2022/lib/process/process-list/components/process-list-cloud.component.mjs

@@ -0,0 +1,594 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Component, ContentChild, EventEmitter, Inject, Input, Output, ViewChild, ViewEncapsulation } from '@angular/core';
+import { AppConfigService, ColumnsSelectorComponent, CustomEmptyContentTemplateDirective, CustomLoadingContentTemplateDirective, DataTableComponent, DataTableSchema, EmptyContentComponent, LoadingContentTemplateDirective, MainMenuDataTableTemplateDirective, NoContentTemplateDirective, UserPreferencesService, UserPreferenceValues } from '@alfresco/adf-core';
+import { ProcessListCloudService } from '../services/process-list-cloud.service';
+import { BehaviorSubject, combineLatest, of, Subject, throwError } from 'rxjs';
+import { processCloudPresetsDefaultModel } from '../models/process-cloud-preset.model';
+import { ProcessListRequestModel, ProcessQueryCloudRequestModel } from '../models/process-cloud-query-request.model';
+import { ProcessListCloudSortingModel, ProcessListRequestSortingModel } from '../models/process-list-sorting.model';
+import { catchError, filter, map, switchMap, take, tap } from 'rxjs/operators';
+import { PROCESS_LISTS_PREFERENCES_SERVICE_TOKEN } from '../../../services/cloud-token.service';
+import { ProcessListCloudPreferences } from '../models/process-cloud-preferences';
+import { ProcessListDatatableAdapter } from '../datatable/process-list-datatable-adapter';
+import { PROCESS_LIST_CUSTOM_VARIABLE_COLUMN } from '../../../models/data-column-custom-data';
+import { VariableMapperService } from '../../../services/variable-mapper.sevice';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { TranslateModule } from '@ngx-translate/core';
+import { NgIf } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/process-list-cloud.service";
+import * as i2 from "@alfresco/adf-core";
+import * as i3 from "../../../services/variable-mapper.sevice";
+import * as i4 from "@angular/material/progress-spinner";
+import * as i5 from "@ngx-translate/core";
+const PRESET_KEY = 'adf-cloud-process-list.presets';
+/* eslint-disable @typescript-eslint/brace-style */
+export class ProcessListCloudComponent extends DataTableSchema {
+    constructor(processListCloudService, appConfigService, userPreferences, cloudPreferenceService, variableMapperService) {
+        super(appConfigService, PRESET_KEY, processCloudPresetsDefaultModel);
+        this.processListCloudService = processListCloudService;
+        this.userPreferences = userPreferences;
+        this.cloudPreferenceService = cloudPreferenceService;
+        this.variableMapperService = variableMapperService;
+        /** The name of the application. */
+        this.appName = '';
+        /** Name of the initiator of the process. */
+        this.initiator = '';
+        /** Filter the processes to display only the ones with this ID. */
+        this.id = '';
+        /** Filter the processes to display only the ones with this name. */
+        this.name = '';
+        /** Filter the processes to display only the ones with this process definition ID. */
+        this.processDefinitionId = '';
+        /** Filter the processes to display only the ones with this process definition name. */
+        this.processDefinitionName = '';
+        /** Filter the processes to display only the ones with this process definition key. */
+        this.processDefinitionKey = '';
+        /** Filter the processes to display only the ones with this status. */
+        this.status = '';
+        /** Filter the processes to display only the ones with this businessKey value. */
+        this.businessKey = '';
+        /** Filter the processes. Display only process with startedDate greater then the supplied date. */
+        this.startFrom = '';
+        /** Filter the processes. Display only process with startedDate less than the supplied date. */
+        this.startTo = '';
+        /** Filter the processes. Display only process with completedFrom equal to the supplied date. */
+        this.completedFrom = '';
+        /** Filter the processes. Display only process with completedTo equal to the supplied date. */
+        this.completedTo = '';
+        /** Filter the processes. Display only process with completedDate equal to the supplied date. */
+        this.completedDate = '';
+        /** Filter the processes. Display only process with suspendedFrom equal to the supplied date. */
+        this.suspendedFrom = '';
+        /** Filter the processes. Display only process with suspendedTo equal to the supplied date. */
+        this.suspendedTo = '';
+        /**
+         * Row selection mode. Can be "none", "single" or "multiple".
+         * For multiple mode, you can use Cmd (macOS) or Ctrl (Win) modifier
+         * key to toggle selection for multiple rows.
+         */
+        this.selectionMode = 'single'; // none|single|multiple
+        /** Toggles multiple row selection and renders checkboxes at the beginning of each row */
+        this.multiselect = false;
+        /** Toggles the data actions column. */
+        this.showActions = false;
+        /** Toggles the provided actions. */
+        this.showProvidedActions = false;
+        /** Position of the actions dropdown menu. Can be "left" or "right". */
+        this.actionsPosition = 'right'; // left|right
+        /** Toggles the sticky header mode. */
+        this.stickyHeader = false;
+        /** Toggles custom context menu for the component. */
+        this.showContextMenu = false;
+        /** Toggle main datatable actions. */
+        this.showMainDatatableActions = false;
+        /** Toggles main datatable column resizing feature. */
+        this.isResizingEnabled = false;
+        /** From Activiti 8.7.0 forward, use 'POST' value and array inputs to enable advanced filtering. */
+        this.searchApiMethod = 'GET';
+        /**
+         * Filter the processes. Display only processes with names matching any of the supplied strings.
+         * This input will be used only if searchApiMethod input is provided with 'POST' value.
+         */
+        this.names = [];
+        /**
+         * Filter the processes. Display only processes with instance Ids matching any of the supplied strings.
+         * This input will be used only if searchApiMethod input is provided with 'POST' value.
+         */
+        this.ids = [];
+        /**
+         * Filter the processes. Display only processes with parent Ids matching any of the supplied strings.
+         * This input will be used only if searchApiMethod input is provided with 'POST' value.
+         */
+        this.parentIds = [];
+        /**
+         * Filter the processes. Display only processes with definition names matching any of the supplied strings.
+         * This input will be used only if searchApiMethod input is provided with 'POST' value.
+         */
+        this.processDefinitionNames = [];
+        /**
+         * Filter the processes. Display only processes started by any of the users whose usernames are present in the array.
+         * This input will be used only if searchApiMethod input is provided with 'POST' value.
+         */
+        this.initiators = [];
+        /**
+         * Filter the processes. Display only processes present in any of the specified app versions.
+         * This input will be used only if searchApiMethod input is provided with 'POST' value.
+         */
+        this.appVersions = [];
+        /**
+         * Filter the processes. Display only processes with provided statuses.
+         * This input will be used only if searchApiMethod input is provided with 'POST' value.
+         */
+        this.statuses = [];
+        /** Emitted when a row in the process list is clicked. */
+        this.rowClick = new EventEmitter();
+        /** Emitted when rows are selected/unselected. */
+        this.rowsSelected = new EventEmitter();
+        /** Emitted before the context menu is displayed for a row. */
+        this.showRowContextMenu = new EventEmitter();
+        /** Emitted before the actions menu is displayed for a row. */
+        this.showRowActionsMenu = new EventEmitter();
+        /** Emitted when the user executes a row action. */
+        this.executeRowAction = new EventEmitter();
+        /** Emitted when an error occurs while loading the list of process instances from the server. */
+        this.error = new EventEmitter();
+        /** Emitted when the list of process instances has been loaded successfully from the server. */
+        this.success = new EventEmitter();
+        this.skipCount = 0;
+        this.isLoading = true;
+        this.rows = [];
+        this.defaultSorting = { key: 'startDate', direction: 'desc' };
+        this.fetchProcessesTrigger$ = new Subject();
+        this.size = userPreferences.paginationSize;
+        this.userPreferences.select(UserPreferenceValues.PaginationSize).subscribe((pageSize) => {
+            this.size = pageSize;
+        });
+        this.pagination = new BehaviorSubject({
+            maxItems: this.size,
+            skipCount: 0,
+            totalItems: 0
+        });
+        combineLatest([this.isColumnSchemaCreated$, this.fetchProcessesTrigger$])
+            .pipe(tap(() => (this.isLoading = true)), filter(([isColumnSchemaCreated]) => isColumnSchemaCreated), switchMap(() => {
+            if (this.searchApiMethod === 'POST') {
+                const requestNode = this.createProcessListRequestNode();
+                this.processListRequestNode = requestNode;
+                return this.processListCloudService.fetchProcessList(requestNode).pipe(take(1));
+            }
+            else {
+                const requestNode = this.createRequestNode();
+                this.requestNode = requestNode;
+                return this.processListCloudService.getProcessByRequest(requestNode).pipe(take(1));
+            }
+        }), takeUntilDestroyed())
+            .subscribe({
+            next: (processes) => {
+                this.rows = this.variableMapperService.mapVariablesByColumnTitle(processes.list.entries, this.columns);
+                this.dataAdapter = new ProcessListDatatableAdapter(this.rows, this.columns);
+                this.success.emit(processes);
+                this.isLoading = false;
+                this.pagination.next(processes.list.pagination);
+            },
+            error: (error) => {
+                console.error(error);
+                this.error.emit(error);
+                this.isLoading = false;
+            }
+        });
+    }
+    ngAfterContentInit() {
+        this.cloudPreferenceService
+            .getPreferences(this.appName)
+            .pipe(take(1), map((preferences) => {
+            const preferencesList = preferences?.list?.entries || [];
+            const columnsOrder = preferencesList.find((preference) => preference.entry.key === ProcessListCloudPreferences.columnOrder);
+            const columnsVisibility = preferencesList.find((preference) => preference.entry.key === ProcessListCloudPreferences.columnsVisibility);
+            const columnsWidths = preferencesList.find((preference) => preference.entry.key === ProcessListCloudPreferences.columnsWidths);
+            return {
+                columnsOrder: columnsOrder ? JSON.parse(columnsOrder.entry.value) : undefined,
+                columnsVisibility: columnsVisibility ? JSON.parse(columnsVisibility.entry.value) : this.columnsVisibility,
+                columnsWidths: columnsWidths ? JSON.parse(columnsWidths.entry.value) : undefined
+            };
+        }), catchError((error) => {
+            if (error.status === 404) {
+                return of({
+                    columnsOrder: undefined,
+                    columnsVisibility: this.columnsVisibility,
+                    columnsWidths: undefined
+                });
+            }
+            else {
+                return throwError(error);
+            }
+        }))
+            .subscribe(({ columnsOrder, columnsVisibility, columnsWidths }) => {
+            if (columnsVisibility) {
+                this.columnsVisibility = columnsVisibility;
+            }
+            if (columnsOrder) {
+                this.columnsOrder = columnsOrder;
+            }
+            if (columnsWidths) {
+                this.columnsWidths = columnsWidths;
+            }
+            this.createDatatableSchema();
+        });
+    }
+    ngOnChanges(changes) {
+        if (this.isPropertyChanged(changes, 'sorting')) {
+            this.formatSorting(changes['sorting'].currentValue);
+        }
+        if (this.isAnyPropertyChanged(changes)) {
+            this.reload();
+        }
+    }
+    getCurrentId() {
+        return this.currentInstanceId;
+    }
+    reload() {
+        if (this.appName || this.appName === '') {
+            this.fetchProcessesTrigger$.next();
+        }
+        else {
+            this.rows = [];
+        }
+    }
+    isAnyPropertyChanged(changes) {
+        for (const property in changes) {
+            if (this.isPropertyChanged(changes, property)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isPropertyChanged(changes, property) {
+        return Object.prototype.hasOwnProperty.call(changes, property);
+    }
+    isListEmpty() {
+        return !this.rows || this.rows.length === 0;
+    }
+    /**
+     * Resets the pagination values
+     */
+    resetPagination() {
+        this.skipCount = 0;
+        this.size = this.userPreferences.paginationSize;
+        this.pagination.next({
+            skipCount: 0,
+            maxItems: this.size
+        });
+    }
+    /**
+     * Resets the pagination values and
+     * Reloads the process list
+     *
+     * @param pagination Pagination values to be set
+     */
+    updatePagination(pagination) {
+        this.size = pagination.maxItems;
+        this.skipCount = pagination.skipCount;
+        this.pagination.next(pagination);
+        this.reload();
+    }
+    onSortingChanged(event) {
+        this.setSorting(event.detail);
+        this.formatSorting(this.sorting);
+        this.reload();
+    }
+    onColumnOrderChanged(columnsWithNewOrder) {
+        this.columnsOrder = columnsWithNewOrder.map((column) => column.id);
+        this.createColumns();
+        if (this.appName) {
+            this.cloudPreferenceService.updatePreference(this.appName, ProcessListCloudPreferences.columnOrder, this.columnsOrder);
+        }
+    }
+    onColumnsVisibilityChange(columns) {
+        this.columnsVisibility = columns.reduce((visibleColumnsMap, column) => {
+            if (column.isHidden !== undefined) {
+                visibleColumnsMap[column.id] = !column.isHidden;
+            }
+            return visibleColumnsMap;
+        }, {});
+        this.createColumns();
+        this.createDatatableSchema();
+        if (this.appName) {
+            this.cloudPreferenceService.updatePreference(this.appName, ProcessListCloudPreferences.columnsVisibility, this.columnsVisibility);
+        }
+    }
+    onColumnsWidthChanged(columns) {
+        const newColumnsWidths = columns.reduce((widthsColumnsMap, column) => {
+            if (column.width) {
+                widthsColumnsMap[column.id] = Math.ceil(column.width);
+            }
+            return widthsColumnsMap;
+        }, {});
+        this.columnsWidths = { ...this.columnsWidths, ...newColumnsWidths };
+        this.createColumns();
+        if (this.appName) {
+            this.cloudPreferenceService.updatePreference(this.appName, ProcessListCloudPreferences.columnsWidths, this.columnsWidths);
+        }
+    }
+    onRowClick(item) {
+        this.currentInstanceId = item.value.getValue('id');
+        this.rowClick.emit(this.currentInstanceId);
+    }
+    onRowSelect(event) {
+        this.selectedInstances = [...event.detail.selection];
+        this.rowsSelected.emit(this.selectedInstances);
+    }
+    onRowUnselect(event) {
+        this.selectedInstances = [...event.detail.selection];
+        this.rowsSelected.emit(this.selectedInstances);
+    }
+    onRowKeyUp(event) {
+        if (event.detail.keyboardEvent.key === 'Enter') {
+            event.preventDefault();
+            this.currentInstanceId = event.detail.row.getValue('id');
+            this.rowClick.emit(this.currentInstanceId);
+        }
+    }
+    onShowRowActionsMenu(event) {
+        this.showRowActionsMenu.emit(event);
+    }
+    onShowRowContextMenu(event) {
+        this.showRowContextMenu.emit(event);
+    }
+    onExecuteRowAction(row) {
+        this.executeRowAction.emit(row);
+    }
+    createProcessListRequestNode() {
+        const requestNode = {
+            appName: this.appName,
+            pagination: {
+                maxItems: this.size,
+                skipCount: this.skipCount
+            },
+            sorting: this.getProcessListRequestSorting(),
+            name: this.names,
+            id: this.ids,
+            parentId: this.parentIds,
+            processDefinitionName: this.processDefinitionNames,
+            initiator: this.initiators,
+            appVersion: this.appVersions,
+            status: this.statuses,
+            lastModifiedFrom: this.lastModifiedFrom?.toISOString() || '',
+            lasModifiedTo: this.lastModifiedTo?.toISOString() || '',
+            startFrom: this.startFrom,
+            startTo: this.startTo,
+            completedFrom: this.completedFrom,
+            completedTo: this.completedTo,
+            suspendedFrom: this.suspendedFrom,
+            suspendedTo: this.suspendedTo,
+            processVariableKeys: this.getVariableDefinitionsRequestModel(),
+            processVariableFilters: this.processVariables
+        };
+        return new ProcessListRequestModel(requestNode);
+    }
+    getProcessListRequestSorting() {
+        if (!this.sorting?.length) {
+            return new ProcessListRequestSortingModel({
+                orderBy: this.defaultSorting.key,
+                direction: this.defaultSorting.direction,
+                isFieldProcessVariable: false
+            });
+        }
+        const orderBy = this.sorting[0]?.orderBy;
+        const direction = this.sorting[0]?.direction;
+        const orderByColumn = this.columnList?.columns.find((column) => column.key === orderBy);
+        const isFieldProcessVariable = orderByColumn?.customData?.columnType === 'process-variable-column';
+        if (isFieldProcessVariable) {
+            const processDefinitionKey = orderByColumn.customData.variableDefinitionsPayload[0].split('/')[0];
+            const variableName = orderByColumn.customData.variableDefinitionsPayload[0].split('/')[1];
+            return new ProcessListRequestSortingModel({
+                orderBy: variableName,
+                direction,
+                isFieldProcessVariable: true,
+                processVariableData: {
+                    processDefinitionKey,
+                    type: orderByColumn.customData.variableType
+                }
+            });
+        }
+        else {
+            return new ProcessListRequestSortingModel({ orderBy, direction, isFieldProcessVariable: false });
+        }
+    }
+    createRequestNode() {
+        const requestNode = {
+            appName: this.appName,
+            appVersion: this.getAppVersions(),
+            maxItems: this.size,
+            skipCount: this.skipCount,
+            initiator: this.initiator,
+            id: this.id,
+            environmentId: this.environmentId,
+            name: this.name,
+            parentId: this.parentId,
+            processDefinitionId: this.processDefinitionId,
+            processDefinitionName: this.processDefinitionName,
+            processDefinitionKey: this.processDefinitionKey,
+            status: this.status,
+            businessKey: this.businessKey,
+            lastModifiedFrom: this.lastModifiedFrom,
+            lastModifiedTo: this.lastModifiedTo,
+            startFrom: this.startFrom,
+            startTo: this.startTo,
+            completedFrom: this.completedFrom,
+            completedTo: this.completedTo,
+            suspendedFrom: this.suspendedFrom,
+            suspendedTo: this.suspendedTo,
+            completedDate: this.completedDate,
+            sorting: this.sorting,
+            variableKeys: this.getVariableDefinitionsRequestModel()
+        };
+        return new ProcessQueryCloudRequestModel(requestNode);
+    }
+    getAppVersions() {
+        return this.appVersion instanceof Array ? this.appVersion.join(',') : this.appVersion ? String(this.appVersion) : '';
+    }
+    setSorting(sortDetail) {
+        const sorting = sortDetail
+            ? {
+                orderBy: sortDetail.key,
+                direction: sortDetail.direction.toUpperCase()
+            }
+            : { ...this.defaultSorting };
+        this.sorting = [new ProcessListCloudSortingModel(sorting)];
+    }
+    formatSorting(sorting) {
+        this.formattedSorting = this.isValidSorting(sorting) ? [sorting[0].orderBy, sorting[0].direction.toLocaleLowerCase()] : null;
+    }
+    isValidSorting(sorting) {
+        return sorting.length && sorting[0].orderBy && sorting[0].direction;
+    }
+    getVariableDefinitionsRequestModel() {
+        const displayedVariableColumns = this.columns
+            .filter((column) => column.customData?.columnType === PROCESS_LIST_CUSTOM_VARIABLE_COLUMN && column.isHidden !== true)
+            .map((column) => {
+            const variableDefinitionsPayload = column.customData.variableDefinitionsPayload;
+            return variableDefinitionsPayload;
+        })
+            .reduce((variablesPayload, payload) => [...variablesPayload, ...payload], []);
+        return displayedVariableColumns.length ? displayedVariableColumns : undefined;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessListCloudComponent, deps: [{ token: i1.ProcessListCloudService }, { token: i2.AppConfigService }, { token: i2.UserPreferencesService }, { token: PROCESS_LISTS_PREFERENCES_SERVICE_TOKEN }, { token: i3.VariableMapperService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: ProcessListCloudComponent, isStandalone: true, selector: "adf-cloud-process-list", inputs: { appName: "appName", appVersion: "appVersion", initiator: "initiator", id: "id", environmentId: "environmentId", name: "name", parentId: "parentId", processDefinitionId: "processDefinitionId", processDefinitionName: "processDefinitionName", processDefinitionKey: "processDefinitionKey", status: "status", businessKey: "businessKey", lastModifiedFrom: "lastModifiedFrom", lastModifiedTo: "lastModifiedTo", startFrom: "startFrom", startTo: "startTo", completedFrom: "completedFrom", completedTo: "completedTo", completedDate: "completedDate", suspendedFrom: "suspendedFrom", suspendedTo: "suspendedTo", selectionMode: "selectionMode", multiselect: "multiselect", sorting: "sorting", showActions: "showActions", showProvidedActions: "showProvidedActions", actionsPosition: "actionsPosition", stickyHeader: "stickyHeader", showContextMenu: "showContextMenu", showMainDatatableActions: "showMainDatatableActions", isResizingEnabled: "isResizingEnabled", searchApiMethod: "searchApiMethod", names: "names", ids: "ids", parentIds: "parentIds", processDefinitionNames: "processDefinitionNames", initiators: "initiators", appVersions: "appVersions", statuses: "statuses", processVariables: "processVariables" }, outputs: { rowClick: "rowClick", rowsSelected: "rowsSelected", showRowContextMenu: "showRowContextMenu", showRowActionsMenu: "showRowActionsMenu", executeRowAction: "executeRowAction", error: "error", success: "success" }, queries: [{ propertyName: "emptyCustomContent", first: true, predicate: CustomEmptyContentTemplateDirective, descendants: true }, { propertyName: "customLoadingContent", first: true, predicate: CustomLoadingContentTemplateDirective, descendants: true }], viewQueries: [{ propertyName: "dataTable", first: true, predicate: DataTableComponent, descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<adf-datatable\n        [rows]=\"rows\"\n        [columns]=\"columns\"\n        [data]=\"dataAdapter\"\n        [stickyHeader]=\"stickyHeader\"\n        [loading]=\"isLoading\"\n        [sorting]=\"formattedSorting\"\n        [selectionMode]=\"selectionMode\"\n        [multiselect]=\"multiselect\"\n        [actions]=\"showActions\"\n        [actionsPosition]=\"actionsPosition\"\n        [contextMenu]=\"showContextMenu\"\n        [showMainDatatableActions]=\"showMainDatatableActions\"\n        [showProvidedActions]=\"showProvidedActions\"\n        [isResizingEnabled]=\"isResizingEnabled\"\n        (showRowActionsMenu)=\"onShowRowActionsMenu($event)\"\n        (showRowContextMenu)=\"onShowRowContextMenu($event)\"\n        (executeRowAction)=\"onExecuteRowAction($event)\"\n        (rowClick)=\"onRowClick($any($event))\"\n        (row-select)=\"onRowSelect($any($event))\"\n        (row-unselect)=\"onRowUnselect($any($event))\"\n        (row-keyup)=\"onRowKeyUp($any($event))\"\n        (sorting-changed)=\"onSortingChanged($any($event))\"\n        (columnOrderChanged)=\"onColumnOrderChanged($event)\"\n        (columnsWidthChanged)=\"onColumnsWidthChanged($event)\"\n        >\n        <adf-loading-content-template>\n            <ng-template>\n                <mat-progress-spinner\n                    *ngIf=\"!customLoadingContent\"\n                    class=\"adf-cloud-process-list-loading-margin\"\n                    [color]=\"'primary'\"\n                    [mode]=\"'indeterminate'\" />\n                <ng-content select=\"adf-custom-loading-content-template\" />\n            </ng-template>\n        </adf-loading-content-template>\n        <adf-no-content-template>\n            <ng-template>\n                <adf-empty-content *ngIf=\"!emptyCustomContent\"\n                    icon=\"assessment\"\n                    [title]=\"'ADF_CLOUD_PROCESS_LIST.MESSAGES.TITLE' | translate\"\n                    [subtitle]=\"'ADF_CLOUD_PROCESS_LIST.MESSAGES.SUBTITLE'| translate\" />\n                <ng-content select=\"adf-custom-empty-content-template\" />\n            </ng-template>\n        </adf-no-content-template>\n\n        <adf-main-menu-datatable-template>\n            <ng-template let-mainMenuTrigger>\n                <adf-datatable-column-selector\n                    [columns]=\"columns\"\n                    [mainMenuTrigger]=\"mainMenuTrigger\"\n                    (submitColumnsVisibility)=\"onColumnsVisibilityChange($event)\" />\n            </ng-template>\n        </adf-main-menu-datatable-template>\n</adf-datatable>\n", styles: [".adf-cloud-process-list-loading-margin{margin-left:calc((100% - 100px)/2);margin-right:calc((100% - 100px)/2)}\n"], dependencies: [{ kind: "component", type: DataTableComponent, selector: "adf-datatable", inputs: ["data", "rows", "sorting", "columns", "selectionMode", "multiselect", "mainTableAction", "actions", "showMainDatatableActions", "showProvidedActions", "actionsPosition", "actionsVisibleOnHover", "fallbackThumbnail", "contextMenu", "rowStyle", "rowStyleClass", "showHeader", "stickyHeader", "loading", "noPermission", "rowMenuCacheEnabled", "resolverFn", "allowFiltering", "isResizingEnabled", "blurOnResize", "displayCheckboxesOnHover", "enableDragRows"], outputs: ["rowClick", "rowDblClick", "showRowContextMenu", "showRowActionsMenu", "executeRowAction", "columnOrderChanged", "columnsWidthChanged", "selectedItemsCountChanged", "dragDropped"] }, { kind: "ngmodule", type: MatProgressSpinnerModule }, { kind: "component", type: i4.MatProgressSpinner, selector: "mat-progress-spinner, mat-spinner", inputs: ["color", "mode", "value", "diameter", "strokeWidth"], exportAs: ["matProgressSpinner"] }, { kind: "ngmodule", type: TranslateModule }, { kind: "pipe", type: i5.TranslatePipe, name: "translate" }, { kind: "component", type: ColumnsSelectorComponent, selector: "adf-datatable-column-selector", inputs: ["columns", "mainMenuTrigger", "columnsSorting", "maxColumnsVisible"], outputs: ["submitColumnsVisibility"] }, { kind: "directive", type: MainMenuDataTableTemplateDirective, selector: "adf-main-menu-datatable-template" }, { kind: "component", type: EmptyContentComponent, selector: "adf-empty-content", inputs: ["icon", "title", "subtitle"] }, { kind: "directive", type: NoContentTemplateDirective, selector: "adf-no-content-template, no-content-template" }, { kind: "directive", type: LoadingContentTemplateDirective, selector: "adf-loading-content-template, loading-content-template" }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ProcessListCloudComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-cloud-process-list', standalone: true, imports: [
+                        DataTableComponent,
+                        MatProgressSpinnerModule,
+                        TranslateModule,
+                        ColumnsSelectorComponent,
+                        MainMenuDataTableTemplateDirective,
+                        EmptyContentComponent,
+                        NoContentTemplateDirective,
+                        LoadingContentTemplateDirective,
+                        NgIf
+                    ], encapsulation: ViewEncapsulation.None, template: "<adf-datatable\n        [rows]=\"rows\"\n        [columns]=\"columns\"\n        [data]=\"dataAdapter\"\n        [stickyHeader]=\"stickyHeader\"\n        [loading]=\"isLoading\"\n        [sorting]=\"formattedSorting\"\n        [selectionMode]=\"selectionMode\"\n        [multiselect]=\"multiselect\"\n        [actions]=\"showActions\"\n        [actionsPosition]=\"actionsPosition\"\n        [contextMenu]=\"showContextMenu\"\n        [showMainDatatableActions]=\"showMainDatatableActions\"\n        [showProvidedActions]=\"showProvidedActions\"\n        [isResizingEnabled]=\"isResizingEnabled\"\n        (showRowActionsMenu)=\"onShowRowActionsMenu($event)\"\n        (showRowContextMenu)=\"onShowRowContextMenu($event)\"\n        (executeRowAction)=\"onExecuteRowAction($event)\"\n        (rowClick)=\"onRowClick($any($event))\"\n        (row-select)=\"onRowSelect($any($event))\"\n        (row-unselect)=\"onRowUnselect($any($event))\"\n        (row-keyup)=\"onRowKeyUp($any($event))\"\n        (sorting-changed)=\"onSortingChanged($any($event))\"\n        (columnOrderChanged)=\"onColumnOrderChanged($event)\"\n        (columnsWidthChanged)=\"onColumnsWidthChanged($event)\"\n        >\n        <adf-loading-content-template>\n            <ng-template>\n                <mat-progress-spinner\n                    *ngIf=\"!customLoadingContent\"\n                    class=\"adf-cloud-process-list-loading-margin\"\n                    [color]=\"'primary'\"\n                    [mode]=\"'indeterminate'\" />\n                <ng-content select=\"adf-custom-loading-content-template\" />\n            </ng-template>\n        </adf-loading-content-template>\n        <adf-no-content-template>\n            <ng-template>\n                <adf-empty-content *ngIf=\"!emptyCustomContent\"\n                    icon=\"assessment\"\n                    [title]=\"'ADF_CLOUD_PROCESS_LIST.MESSAGES.TITLE' | translate\"\n                    [subtitle]=\"'ADF_CLOUD_PROCESS_LIST.MESSAGES.SUBTITLE'| translate\" />\n                <ng-content select=\"adf-custom-empty-content-template\" />\n            </ng-template>\n        </adf-no-content-template>\n\n        <adf-main-menu-datatable-template>\n            <ng-template let-mainMenuTrigger>\n                <adf-datatable-column-selector\n                    [columns]=\"columns\"\n                    [mainMenuTrigger]=\"mainMenuTrigger\"\n                    (submitColumnsVisibility)=\"onColumnsVisibilityChange($event)\" />\n            </ng-template>\n        </adf-main-menu-datatable-template>\n</adf-datatable>\n", styles: [".adf-cloud-process-list-loading-margin{margin-left:calc((100% - 100px)/2);margin-right:calc((100% - 100px)/2)}\n"] }]
+        }], ctorParameters: () => [{ type: i1.ProcessListCloudService }, { type: i2.AppConfigService }, { type: i2.UserPreferencesService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PROCESS_LISTS_PREFERENCES_SERVICE_TOKEN]
+                }] }, { type: i3.VariableMapperService }], propDecorators: { dataTable: [{
+                type: ViewChild,
+                args: [DataTableComponent]
+            }], emptyCustomContent: [{
+                type: ContentChild,
+                args: [CustomEmptyContentTemplateDirective]
+            }], customLoadingContent: [{
+                type: ContentChild,
+                args: [CustomLoadingContentTemplateDirective]
+            }], appName: [{
+                type: Input
+            }], appVersion: [{
+                type: Input
+            }], initiator: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], environmentId: [{
+                type: Input
+            }], name: [{
+                type: Input
+            }], parentId: [{
+                type: Input
+            }], processDefinitionId: [{
+                type: Input
+            }], processDefinitionName: [{
+                type: Input
+            }], processDefinitionKey: [{
+                type: Input
+            }], status: [{
+                type: Input
+            }], businessKey: [{
+                type: Input
+            }], lastModifiedFrom: [{
+                type: Input
+            }], lastModifiedTo: [{
+                type: Input
+            }], startFrom: [{
+                type: Input
+            }], startTo: [{
+                type: Input
+            }], completedFrom: [{
+                type: Input
+            }], completedTo: [{
+                type: Input
+            }], completedDate: [{
+                type: Input
+            }], suspendedFrom: [{
+                type: Input
+            }], suspendedTo: [{
+                type: Input
+            }], selectionMode: [{
+                type: Input
+            }], multiselect: [{
+                type: Input
+            }], sorting: [{
+                type: Input
+            }], showActions: [{
+                type: Input
+            }], showProvidedActions: [{
+                type: Input
+            }], actionsPosition: [{
+                type: Input
+            }], stickyHeader: [{
+                type: Input
+            }], showContextMenu: [{
+                type: Input
+            }], showMainDatatableActions: [{
+                type: Input
+            }], isResizingEnabled: [{
+                type: Input
+            }], searchApiMethod: [{
+                type: Input
+            }], names: [{
+                type: Input
+            }], ids: [{
+                type: Input
+            }], parentIds: [{
+                type: Input
+            }], processDefinitionNames: [{
+                type: Input
+            }], initiators: [{
+                type: Input
+            }], appVersions: [{
+                type: Input
+            }], statuses: [{
+                type: Input
+            }], processVariables: [{
+                type: Input
+            }], rowClick: [{
+                type: Output
+            }], rowsSelected: [{
+                type: Output
+            }], showRowContextMenu: [{
+                type: Output
+            }], showRowActionsMenu: [{
+                type: Output
+            }], executeRowAction: [{
+                type: Output
+            }], error: [{
+                type: Output
+            }], success: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"process-list-cloud.component.js","sourceRoot":"","sources":["../../../../../../../../lib/process-services-cloud/src/lib/process/process-list/components/process-list-cloud.component.ts","../../../../../../../../lib/process-services-cloud/src/lib/process/process-list/components/process-list-cloud.component.html"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n    AfterContentInit,\n    Component,\n    ContentChild,\n    EventEmitter,\n    Inject,\n    Input,\n    OnChanges,\n    Output,\n    SimpleChanges,\n    ViewChild,\n    ViewEncapsulation\n} from '@angular/core';\nimport {\n    AppConfigService,\n    ColumnsSelectorComponent,\n    CustomEmptyContentTemplateDirective,\n    CustomLoadingContentTemplateDirective,\n    DataCellEvent,\n    DataColumn,\n    DataRowActionEvent,\n    DataRowEvent,\n    DataTableComponent,\n    DataTableSchema,\n    EmptyContentComponent,\n    LoadingContentTemplateDirective,\n    MainMenuDataTableTemplateDirective,\n    NoContentTemplateDirective,\n    PaginatedComponent,\n    PaginationModel,\n    UserPreferencesService,\n    UserPreferenceValues\n} from '@alfresco/adf-core';\nimport { ProcessListCloudService } from '../services/process-list-cloud.service';\nimport { BehaviorSubject, combineLatest, of, Subject, throwError } from 'rxjs';\nimport { processCloudPresetsDefaultModel } from '../models/process-cloud-preset.model';\nimport { ProcessListRequestModel, ProcessQueryCloudRequestModel } from '../models/process-cloud-query-request.model';\nimport { ProcessListCloudSortingModel, ProcessListRequestSortingModel } from '../models/process-list-sorting.model';\nimport { catchError, filter, map, switchMap, take, tap } from 'rxjs/operators';\nimport { PreferenceCloudServiceInterface } from '../../../services/preference-cloud.interface';\nimport { PROCESS_LISTS_PREFERENCES_SERVICE_TOKEN } from '../../../services/cloud-token.service';\nimport { ProcessListCloudPreferences } from '../models/process-cloud-preferences';\nimport { ProcessListDatatableAdapter } from '../datatable/process-list-datatable-adapter';\nimport { PROCESS_LIST_CUSTOM_VARIABLE_COLUMN, ProcessListDataColumnCustomData } from '../../../models/data-column-custom-data';\nimport { VariableMapperService } from '../../../services/variable-mapper.sevice';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport { ProcessVariableFilterModel } from '../../../models/process-variable-filter.model';\nimport { MatProgressSpinnerModule } from '@angular/material/progress-spinner';\nimport { TranslateModule } from '@ngx-translate/core';\nimport { NgIf } from '@angular/common';\n\nconst PRESET_KEY = 'adf-cloud-process-list.presets';\n\n/* eslint-disable @typescript-eslint/brace-style */\n\n@Component({\n    selector: 'adf-cloud-process-list',\n    standalone: true,\n    imports: [\n        DataTableComponent,\n        MatProgressSpinnerModule,\n        TranslateModule,\n        ColumnsSelectorComponent,\n        MainMenuDataTableTemplateDirective,\n        EmptyContentComponent,\n        NoContentTemplateDirective,\n        LoadingContentTemplateDirective,\n        NgIf\n    ],\n    templateUrl: './process-list-cloud.component.html',\n    styleUrls: ['./process-list-cloud.component.scss'],\n    encapsulation: ViewEncapsulation.None\n})\nexport class ProcessListCloudComponent\n    extends DataTableSchema<ProcessListDataColumnCustomData>\n    implements OnChanges, AfterContentInit, PaginatedComponent\n{\n    @ViewChild(DataTableComponent) dataTable: DataTableComponent;\n\n    @ContentChild(CustomEmptyContentTemplateDirective)\n    emptyCustomContent: CustomEmptyContentTemplateDirective;\n\n    @ContentChild(CustomLoadingContentTemplateDirective)\n    customLoadingContent: CustomLoadingContentTemplateDirective;\n\n    /** The name of the application. */\n    @Input()\n    appName: string = '';\n\n    /** The version of the application. */\n    @Input()\n    appVersion: number | number[];\n\n    /** Name of the initiator of the process. */\n    @Input()\n    initiator: string = '';\n\n    /** Filter the processes to display only the ones with this ID. */\n    @Input()\n    id: string = '';\n\n    /** Filter the processes to display only the ones with this environment ID. */\n    @Input()\n    environmentId: string;\n\n    /** Filter the processes to display only the ones with this name. */\n    @Input()\n    name: string = '';\n\n    /** Filter the processes to display only the ones with this parentId. */\n    @Input()\n    parentId?: string;\n\n    /** Filter the processes to display only the ones with this process definition ID. */\n    @Input()\n    processDefinitionId: string = '';\n\n    /** Filter the processes to display only the ones with this process definition name. */\n    @Input()\n    processDefinitionName: string = '';\n\n    /** Filter the processes to display only the ones with this process definition key. */\n    @Input()\n    processDefinitionKey: string = '';\n\n    /** Filter the processes to display only the ones with this status. */\n    @Input()\n    status: string = '';\n\n    /** Filter the processes to display only the ones with this businessKey value. */\n    @Input()\n    businessKey: string = '';\n\n    /** Filter the processes. Display only process with lastModifiedTo equal to the supplied date. */\n    @Input()\n    lastModifiedFrom: Date;\n\n    /** Filter the processes. Display only process with lastModifiedTo equal to the supplied date. */\n    @Input()\n    lastModifiedTo: Date;\n\n    /** Filter the processes. Display only process with startedDate greater then the supplied date. */\n    @Input()\n    startFrom: string = '';\n\n    /** Filter the processes. Display only process with startedDate less than the supplied date. */\n    @Input()\n    startTo: string = '';\n\n    /** Filter the processes. Display only process with completedFrom equal to the supplied date. */\n    @Input()\n    completedFrom: string = '';\n\n    /** Filter the processes. Display only process with completedTo equal to the supplied date. */\n    @Input()\n    completedTo: string = '';\n\n    /** Filter the processes. Display only process with completedDate equal to the supplied date. */\n    @Input()\n    completedDate: string = '';\n\n    /** Filter the processes. Display only process with suspendedFrom equal to the supplied date. */\n    @Input()\n    suspendedFrom: string = '';\n\n    /** Filter the processes. Display only process with suspendedTo equal to the supplied date. */\n    @Input()\n    suspendedTo: string = '';\n\n    /**\n     * Row selection mode. Can be \"none\", \"single\" or \"multiple\".\n     * For multiple mode, you can use Cmd (macOS) or Ctrl (Win) modifier\n     * key to toggle selection for multiple rows.\n     */\n    @Input()\n    selectionMode: string = 'single'; // none|single|multiple\n\n    /** Toggles multiple row selection and renders checkboxes at the beginning of each row */\n    @Input()\n    multiselect: boolean = false;\n\n    /**\n     * Array of objects specifying the sort order and direction for the\n     * list. The sort parameters are for BE sorting.\n     */\n    @Input()\n    sorting: ProcessListCloudSortingModel[];\n\n    /** Toggles the data actions column. */\n    @Input()\n    showActions: boolean = false;\n\n    /** Toggles the provided actions. */\n    @Input()\n    showProvidedActions: boolean = false;\n\n    /** Position of the actions dropdown menu. Can be \"left\" or \"right\". */\n    @Input()\n    actionsPosition: string = 'right'; // left|right\n\n    /** Toggles the sticky header mode. */\n    @Input()\n    stickyHeader: boolean = false;\n\n    /** Toggles custom context menu for the component. */\n    @Input()\n    showContextMenu: boolean = false;\n\n    /** Toggle main datatable actions. */\n    @Input()\n    showMainDatatableActions: boolean = false;\n\n    /** Toggles main datatable column resizing feature. */\n    @Input()\n    isResizingEnabled: boolean = false;\n\n    /** From Activiti 8.7.0 forward, use 'POST' value and array inputs to enable advanced filtering. */\n    @Input()\n    searchApiMethod: 'GET' | 'POST' = 'GET';\n\n    /**\n     * Filter the processes. Display only processes with names matching any of the supplied strings.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    names: string[] = [];\n\n    /**\n     * Filter the processes. Display only processes with instance Ids matching any of the supplied strings.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    ids: string[] = [];\n\n    /**\n     * Filter the processes. Display only processes with parent Ids matching any of the supplied strings.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    parentIds: string[] = [];\n\n    /**\n     * Filter the processes. Display only processes with definition names matching any of the supplied strings.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    processDefinitionNames: string[] = [];\n\n    /**\n     * Filter the processes. Display only processes started by any of the users whose usernames are present in the array.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    initiators: string[] = [];\n\n    /**\n     * Filter the processes. Display only processes present in any of the specified app versions.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    appVersions: string[] = [];\n\n    /**\n     * Filter the processes. Display only processes with provided statuses.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    statuses: string[] = [];\n\n    /**\n     * Filter the processes. Display only processes with specific process variables.\n     * This input will be used only if searchApiMethod input is provided with 'POST' value.\n     */\n    @Input()\n    processVariables: ProcessVariableFilterModel[];\n\n    /** Emitted when a row in the process list is clicked. */\n    @Output()\n    rowClick: EventEmitter<string> = new EventEmitter<string>();\n\n    /** Emitted when rows are selected/unselected. */\n    @Output()\n    rowsSelected = new EventEmitter<any[]>();\n\n    /** Emitted before the context menu is displayed for a row. */\n    @Output()\n    showRowContextMenu = new EventEmitter<DataCellEvent>();\n\n    /** Emitted before the actions menu is displayed for a row. */\n    @Output()\n    showRowActionsMenu = new EventEmitter<DataCellEvent>();\n\n    /** Emitted when the user executes a row action. */\n    @Output()\n    executeRowAction = new EventEmitter<DataRowActionEvent>();\n\n    /** Emitted when an error occurs while loading the list of process instances from the server. */\n    @Output()\n    error = new EventEmitter<any>();\n\n    /** Emitted when the list of process instances has been loaded successfully from the server. */\n    @Output()\n    success = new EventEmitter<any>();\n\n    pagination: BehaviorSubject<PaginationModel>;\n    size: number;\n    skipCount: number = 0;\n    currentInstanceId: string;\n    selectedInstances: any[];\n    isLoading = true;\n\n    rows: any[] = [];\n    formattedSorting: any[];\n    requestNode: ProcessQueryCloudRequestModel;\n    processListRequestNode: ProcessListRequestModel;\n    dataAdapter: ProcessListDatatableAdapter;\n\n    private defaultSorting = { key: 'startDate', direction: 'desc' };\n\n    private fetchProcessesTrigger$ = new Subject<void>();\n\n    constructor(\n        private processListCloudService: ProcessListCloudService,\n        appConfigService: AppConfigService,\n        private userPreferences: UserPreferencesService,\n        @Inject(PROCESS_LISTS_PREFERENCES_SERVICE_TOKEN) private cloudPreferenceService: PreferenceCloudServiceInterface,\n        private variableMapperService: VariableMapperService\n    ) {\n        super(appConfigService, PRESET_KEY, processCloudPresetsDefaultModel);\n        this.size = userPreferences.paginationSize;\n        this.userPreferences.select(UserPreferenceValues.PaginationSize).subscribe((pageSize) => {\n            this.size = pageSize;\n        });\n        this.pagination = new BehaviorSubject<PaginationModel>({\n            maxItems: this.size,\n            skipCount: 0,\n            totalItems: 0\n        });\n\n        combineLatest([this.isColumnSchemaCreated$, this.fetchProcessesTrigger$])\n            .pipe(\n                tap(() => (this.isLoading = true)),\n                filter(([isColumnSchemaCreated]) => isColumnSchemaCreated),\n                switchMap(() => {\n                    if (this.searchApiMethod === 'POST') {\n                        const requestNode = this.createProcessListRequestNode();\n                        this.processListRequestNode = requestNode;\n                        return this.processListCloudService.fetchProcessList(requestNode).pipe(take(1));\n                    } else {\n                        const requestNode = this.createRequestNode();\n                        this.requestNode = requestNode;\n                        return this.processListCloudService.getProcessByRequest(requestNode).pipe(take(1));\n                    }\n                }),\n                takeUntilDestroyed()\n            )\n            .subscribe({\n                next: (processes) => {\n                    this.rows = this.variableMapperService.mapVariablesByColumnTitle(processes.list.entries, this.columns);\n\n                    this.dataAdapter = new ProcessListDatatableAdapter(this.rows, this.columns);\n\n                    this.success.emit(processes);\n                    this.isLoading = false;\n                    this.pagination.next(processes.list.pagination);\n                },\n                error: (error) => {\n                    console.error(error);\n                    this.error.emit(error);\n                    this.isLoading = false;\n                }\n            });\n    }\n\n    ngAfterContentInit() {\n        this.cloudPreferenceService\n            .getPreferences(this.appName)\n            .pipe(\n                take(1),\n                map((preferences) => {\n                    const preferencesList = preferences?.list?.entries || [];\n                    const columnsOrder = preferencesList.find((preference) => preference.entry.key === ProcessListCloudPreferences.columnOrder);\n                    const columnsVisibility = preferencesList.find(\n                        (preference) => preference.entry.key === ProcessListCloudPreferences.columnsVisibility\n                    );\n                    const columnsWidths = preferencesList.find((preference) => preference.entry.key === ProcessListCloudPreferences.columnsWidths);\n\n                    return {\n                        columnsOrder: columnsOrder ? JSON.parse(columnsOrder.entry.value) : undefined,\n                        columnsVisibility: columnsVisibility ? JSON.parse(columnsVisibility.entry.value) : this.columnsVisibility,\n                        columnsWidths: columnsWidths ? JSON.parse(columnsWidths.entry.value) : undefined\n                    };\n                }),\n                catchError((error) => {\n                    if (error.status === 404) {\n                        return of({\n                            columnsOrder: undefined,\n                            columnsVisibility: this.columnsVisibility,\n                            columnsWidths: undefined\n                        });\n                    } else {\n                        return throwError(error);\n                    }\n                })\n            )\n            .subscribe(({ columnsOrder, columnsVisibility, columnsWidths }) => {\n                if (columnsVisibility) {\n                    this.columnsVisibility = columnsVisibility;\n                }\n\n                if (columnsOrder) {\n                    this.columnsOrder = columnsOrder;\n                }\n\n                if (columnsWidths) {\n                    this.columnsWidths = columnsWidths;\n                }\n\n                this.createDatatableSchema();\n            });\n    }\n    ngOnChanges(changes: SimpleChanges) {\n        if (this.isPropertyChanged(changes, 'sorting')) {\n            this.formatSorting(changes['sorting'].currentValue);\n        }\n\n        if (this.isAnyPropertyChanged(changes)) {\n            this.reload();\n        }\n    }\n\n    getCurrentId(): string {\n        return this.currentInstanceId;\n    }\n\n    reload() {\n        if (this.appName || this.appName === '') {\n            this.fetchProcessesTrigger$.next();\n        } else {\n            this.rows = [];\n        }\n    }\n\n    private isAnyPropertyChanged(changes: SimpleChanges): boolean {\n        for (const property in changes) {\n            if (this.isPropertyChanged(changes, property)) {\n                return true;\n            }\n        }\n        return false;\n    }\n\n    private isPropertyChanged(changes: SimpleChanges, property: string): boolean {\n        return Object.prototype.hasOwnProperty.call(changes, property);\n    }\n\n    isListEmpty(): boolean {\n        return !this.rows || this.rows.length === 0;\n    }\n\n    /**\n     * Resets the pagination values\n     */\n    resetPagination() {\n        this.skipCount = 0;\n        this.size = this.userPreferences.paginationSize;\n        this.pagination.next({\n            skipCount: 0,\n            maxItems: this.size\n        });\n    }\n\n    /**\n     * Resets the pagination values and\n     * Reloads the process list\n     *\n     * @param pagination Pagination values to be set\n     */\n    updatePagination(pagination: PaginationModel) {\n        this.size = pagination.maxItems;\n        this.skipCount = pagination.skipCount;\n        this.pagination.next(pagination);\n        this.reload();\n    }\n\n    onSortingChanged(event: CustomEvent) {\n        this.setSorting(event.detail);\n        this.formatSorting(this.sorting);\n        this.reload();\n    }\n\n    onColumnOrderChanged(columnsWithNewOrder: DataColumn[]): void {\n        this.columnsOrder = columnsWithNewOrder.map((column) => column.id);\n        this.createColumns();\n\n        if (this.appName) {\n            this.cloudPreferenceService.updatePreference(this.appName, ProcessListCloudPreferences.columnOrder, this.columnsOrder);\n        }\n    }\n\n    onColumnsVisibilityChange(columns: DataColumn[]): void {\n        this.columnsVisibility = columns.reduce((visibleColumnsMap, column) => {\n            if (column.isHidden !== undefined) {\n                visibleColumnsMap[column.id] = !column.isHidden;\n            }\n\n            return visibleColumnsMap;\n        }, {});\n\n        this.createColumns();\n        this.createDatatableSchema();\n\n        if (this.appName) {\n            this.cloudPreferenceService.updatePreference(this.appName, ProcessListCloudPreferences.columnsVisibility, this.columnsVisibility);\n        }\n    }\n\n    onColumnsWidthChanged(columns: DataColumn[]): void {\n        const newColumnsWidths = columns.reduce((widthsColumnsMap, column) => {\n            if (column.width) {\n                widthsColumnsMap[column.id] = Math.ceil(column.width);\n            }\n            return widthsColumnsMap;\n        }, {});\n\n        this.columnsWidths = { ...this.columnsWidths, ...newColumnsWidths };\n\n        this.createColumns();\n\n        if (this.appName) {\n            this.cloudPreferenceService.updatePreference(this.appName, ProcessListCloudPreferences.columnsWidths, this.columnsWidths);\n        }\n    }\n\n    onRowClick(item: DataRowEvent) {\n        this.currentInstanceId = item.value.getValue('id');\n        this.rowClick.emit(this.currentInstanceId);\n    }\n\n    onRowSelect(event: CustomEvent) {\n        this.selectedInstances = [...event.detail.selection];\n        this.rowsSelected.emit(this.selectedInstances);\n    }\n\n    onRowUnselect(event: CustomEvent) {\n        this.selectedInstances = [...event.detail.selection];\n        this.rowsSelected.emit(this.selectedInstances);\n    }\n\n    onRowKeyUp(event: CustomEvent) {\n        if (event.detail.keyboardEvent.key === 'Enter') {\n            event.preventDefault();\n            this.currentInstanceId = event.detail.row.getValue('id');\n            this.rowClick.emit(this.currentInstanceId);\n        }\n    }\n\n    onShowRowActionsMenu(event: DataCellEvent) {\n        this.showRowActionsMenu.emit(event);\n    }\n\n    onShowRowContextMenu(event: DataCellEvent) {\n        this.showRowContextMenu.emit(event);\n    }\n\n    onExecuteRowAction(row: DataRowActionEvent) {\n        this.executeRowAction.emit(row);\n    }\n\n    private createProcessListRequestNode(): ProcessListRequestModel {\n        const requestNode: ProcessListRequestModel = {\n            appName: this.appName,\n            pagination: {\n                maxItems: this.size,\n                skipCount: this.skipCount\n            },\n            sorting: this.getProcessListRequestSorting(),\n            name: this.names,\n            id: this.ids,\n            parentId: this.parentIds,\n            processDefinitionName: this.processDefinitionNames,\n            initiator: this.initiators,\n            appVersion: this.appVersions,\n            status: this.statuses,\n            lastModifiedFrom: this.lastModifiedFrom?.toISOString() || '',\n            lasModifiedTo: this.lastModifiedTo?.toISOString() || '',\n            startFrom: this.startFrom,\n            startTo: this.startTo,\n            completedFrom: this.completedFrom,\n            completedTo: this.completedTo,\n            suspendedFrom: this.suspendedFrom,\n            suspendedTo: this.suspendedTo,\n            processVariableKeys: this.getVariableDefinitionsRequestModel(),\n            processVariableFilters: this.processVariables\n        };\n\n        return new ProcessListRequestModel(requestNode);\n    }\n\n    private getProcessListRequestSorting(): ProcessListRequestSortingModel {\n        if (!this.sorting?.length) {\n            return new ProcessListRequestSortingModel({\n                orderBy: this.defaultSorting.key,\n                direction: this.defaultSorting.direction,\n                isFieldProcessVariable: false\n            });\n        }\n\n        const orderBy = this.sorting[0]?.orderBy;\n        const direction = this.sorting[0]?.direction;\n        const orderByColumn = this.columnList?.columns.find((column) => column.key === orderBy);\n        const isFieldProcessVariable = orderByColumn?.customData?.columnType === 'process-variable-column';\n\n        if (isFieldProcessVariable) {\n            const processDefinitionKey = orderByColumn.customData.variableDefinitionsPayload[0].split('/')[0];\n            const variableName = orderByColumn.customData.variableDefinitionsPayload[0].split('/')[1];\n            return new ProcessListRequestSortingModel({\n                orderBy: variableName,\n                direction,\n                isFieldProcessVariable: true,\n                processVariableData: {\n                    processDefinitionKey,\n                    type: orderByColumn.customData.variableType\n                }\n            });\n        } else {\n            return new ProcessListRequestSortingModel({ orderBy, direction, isFieldProcessVariable: false });\n        }\n    }\n\n    private createRequestNode(): ProcessQueryCloudRequestModel {\n        const requestNode = {\n            appName: this.appName,\n            appVersion: this.getAppVersions(),\n            maxItems: this.size,\n            skipCount: this.skipCount,\n            initiator: this.initiator,\n            id: this.id,\n            environmentId: this.environmentId,\n            name: this.name,\n            parentId: this.parentId,\n            processDefinitionId: this.processDefinitionId,\n            processDefinitionName: this.processDefinitionName,\n            processDefinitionKey: this.processDefinitionKey,\n            status: this.status,\n            businessKey: this.businessKey,\n            lastModifiedFrom: this.lastModifiedFrom,\n            lastModifiedTo: this.lastModifiedTo,\n            startFrom: this.startFrom,\n            startTo: this.startTo,\n            completedFrom: this.completedFrom,\n            completedTo: this.completedTo,\n            suspendedFrom: this.suspendedFrom,\n            suspendedTo: this.suspendedTo,\n            completedDate: this.completedDate,\n            sorting: this.sorting,\n            variableKeys: this.getVariableDefinitionsRequestModel()\n        };\n\n        return new ProcessQueryCloudRequestModel(requestNode);\n    }\n\n    getAppVersions(): string {\n        return this.appVersion instanceof Array ? this.appVersion.join(',') : this.appVersion ? String(this.appVersion) : '';\n    }\n\n    setSorting(sortDetail) {\n        const sorting = sortDetail\n            ? {\n                  orderBy: sortDetail.key,\n                  direction: sortDetail.direction.toUpperCase()\n              }\n            : { ...this.defaultSorting };\n        this.sorting = [new ProcessListCloudSortingModel(sorting)];\n    }\n\n    formatSorting(sorting: ProcessListCloudSortingModel[]) {\n        this.formattedSorting = this.isValidSorting(sorting) ? [sorting[0].orderBy, sorting[0].direction.toLocaleLowerCase()] : null;\n    }\n\n    isValidSorting(sorting: ProcessListCloudSortingModel[]) {\n        return sorting.length && sorting[0].orderBy && sorting[0].direction;\n    }\n\n    private getVariableDefinitionsRequestModel(): string[] | undefined {\n        const displayedVariableColumns = this.columns\n            .filter((column) => column.customData?.columnType === PROCESS_LIST_CUSTOM_VARIABLE_COLUMN && column.isHidden !== true)\n            .map((column) => {\n                const variableDefinitionsPayload = column.customData.variableDefinitionsPayload;\n                return variableDefinitionsPayload;\n            })\n            .reduce((variablesPayload, payload) => [...variablesPayload, ...payload], []);\n\n        return displayedVariableColumns.length ? displayedVariableColumns : undefined;\n    }\n}\n","<adf-datatable\n        [rows]=\"rows\"\n        [columns]=\"columns\"\n        [data]=\"dataAdapter\"\n        [stickyHeader]=\"stickyHeader\"\n        [loading]=\"isLoading\"\n        [sorting]=\"formattedSorting\"\n        [selectionMode]=\"selectionMode\"\n        [multiselect]=\"multiselect\"\n        [actions]=\"showActions\"\n        [actionsPosition]=\"actionsPosition\"\n        [contextMenu]=\"showContextMenu\"\n        [showMainDatatableActions]=\"showMainDatatableActions\"\n        [showProvidedActions]=\"showProvidedActions\"\n        [isResizingEnabled]=\"isResizingEnabled\"\n        (showRowActionsMenu)=\"onShowRowActionsMenu($event)\"\n        (showRowContextMenu)=\"onShowRowContextMenu($event)\"\n        (executeRowAction)=\"onExecuteRowAction($event)\"\n        (rowClick)=\"onRowClick($any($event))\"\n        (row-select)=\"onRowSelect($any($event))\"\n        (row-unselect)=\"onRowUnselect($any($event))\"\n        (row-keyup)=\"onRowKeyUp($any($event))\"\n        (sorting-changed)=\"onSortingChanged($any($event))\"\n        (columnOrderChanged)=\"onColumnOrderChanged($event)\"\n        (columnsWidthChanged)=\"onColumnsWidthChanged($event)\"\n        >\n        <adf-loading-content-template>\n            <ng-template>\n                <mat-progress-spinner\n                    *ngIf=\"!customLoadingContent\"\n                    class=\"adf-cloud-process-list-loading-margin\"\n                    [color]=\"'primary'\"\n                    [mode]=\"'indeterminate'\" />\n                <ng-content select=\"adf-custom-loading-content-template\" />\n            </ng-template>\n        </adf-loading-content-template>\n        <adf-no-content-template>\n            <ng-template>\n                <adf-empty-content *ngIf=\"!emptyCustomContent\"\n                    icon=\"assessment\"\n                    [title]=\"'ADF_CLOUD_PROCESS_LIST.MESSAGES.TITLE' | translate\"\n                    [subtitle]=\"'ADF_CLOUD_PROCESS_LIST.MESSAGES.SUBTITLE'| translate\" />\n                <ng-content select=\"adf-custom-empty-content-template\" />\n            </ng-template>\n        </adf-no-content-template>\n\n        <adf-main-menu-datatable-template>\n            <ng-template let-mainMenuTrigger>\n                <adf-datatable-column-selector\n                    [columns]=\"columns\"\n                    [mainMenuTrigger]=\"mainMenuTrigger\"\n                    (submitColumnsVisibility)=\"onColumnsVisibilityChange($event)\" />\n            </ng-template>\n        </adf-main-menu-datatable-template>\n</adf-datatable>\n"]}