@alfresco/adf-process-services-cloud 8.1.0-16120632321 → 8.1.0-16121703802

package/esm2022/lib/task/task-filters/components/edit-task-filters/base-edit-task-filter-cloud.component.mjs

@@ -0,0 +1,467 @@
+/*!
+ * @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 { DestroyRef, Directive, EventEmitter, inject, Input, Output } from '@angular/core';
+import { AssignmentType, TaskStatusFilter } from '../../models/filter-cloud.model';
+import { TaskCloudService } from './../../../services/task-cloud.service';
+import { AppsProcessCloudService } from './../../../../app/services/apps-process-cloud.service';
+import { DateCloudFilterType } from '../../../../models/date-cloud-filter.model';
+import { UntypedFormBuilder } from '@angular/forms';
+import { debounceTime, filter, finalize, switchMap } from 'rxjs/operators';
+import { DateAdapter } from '@angular/material/core';
+import { DateFnsUtils, TranslationService, UserPreferencesService, UserPreferenceValues } from '@alfresco/adf-core';
+import { TaskFilterDialogCloudComponent } from '../task-filter-dialog/task-filter-dialog-cloud.component';
+import { MatDialog } from '@angular/material/dialog';
+import { isValid } from 'date-fns';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import * as i0 from "@angular/core";
+const ACTION_SAVE = 'save';
+const ACTION_SAVE_AS = 'saveAs';
+const ACTION_DELETE = 'delete';
+const APP_DEPLOYED_STATUS = 'DEPLOYED';
+const APPLICATION_NAME = 'appName';
+const PROCESS_DEFINITION_NAME = 'processDefinitionName';
+const LAST_MODIFIED_PROPERTY = 'lastModified';
+const DATE_FORMAT = 'DD/MM/YYYY';
+const DEFAULT_ACTIONS = [ACTION_SAVE, ACTION_SAVE_AS, ACTION_DELETE];
+const SORT_PROPERTY = 'sort';
+const ORDER_PROPERTY = 'order';
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+export class BaseEditTaskFilterCloudComponent {
+    constructor() {
+        /** (required) Name of the app. */
+        this.appName = '';
+        /** List of environments. */
+        this.environmentList = [];
+        /** Toggles the title. */
+        this.showTitle = true;
+        /** Toggles display of task filter name */
+        this.showTaskFilterName = true;
+        /** List of task filter properties to display. */
+        this.filterProperties = [];
+        /** user role. */
+        this.role = '';
+        /** Toggles the filter actions. */
+        this.showFilterActions = true;
+        /** List of task filter actions. */
+        this.actions = [...DEFAULT_ACTIONS];
+        /** List of sort properties to display. */
+        this.sortProperties = [];
+        /** Emitted when a filter action occurs (i.e Save, Save As, Delete). */
+        this.action = new EventEmitter();
+        this.applicationNames = [];
+        this.processDefinitionNames = [];
+        this.formHasBeenChanged = false;
+        this.taskFilterProperties = [];
+        this.taskFilterActions = [];
+        this.toggleFilterActions = false;
+        this.sortDirections = [
+            { value: 'ASC', label: 'ADF_CLOUD_TASK_FILTERS.DIRECTION.ASCENDING' },
+            { value: 'DESC', label: 'ADF_CLOUD_TASK_FILTERS.DIRECTION.DESCENDING' }
+        ];
+        this.allProcessDefinitionNamesOption = {
+            value: '',
+            label: 'ADF_CLOUD_TASK_FILTERS.STATUS.ALL'
+        };
+        /** Emitted when a task filter property changes. */
+        this.filterChange = new EventEmitter();
+        this.isLoading = false;
+        this.destroyRef = inject(DestroyRef);
+        this.translateService = inject(TranslationService);
+        this.taskCloudService = inject(TaskCloudService);
+        this.userPreferencesService = inject(UserPreferencesService);
+        this.appsProcessCloudService = inject(AppsProcessCloudService);
+        this.dialog = inject(MatDialog);
+        this.formBuilder = inject(UntypedFormBuilder);
+        this.dateAdapter = inject(DateAdapter);
+    }
+    static { this.ACTIONS_DISABLED_BY_DEFAULT = [ACTION_SAVE, ACTION_DELETE]; }
+    ngOnInit() {
+        this.userPreferencesService
+            .select(UserPreferenceValues.Locale)
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe((locale) => this.dateAdapter.setLocale(locale));
+    }
+    ngOnChanges(changes) {
+        const { id } = changes;
+        if (id && id.currentValue !== id.previousValue) {
+            if (this.taskFilter && this.taskFilter['id'] === id.currentValue) {
+                this.taskFilterProperties = this.createAndFilterProperties();
+                this.taskFilterActions = this.createAndFilterActions();
+                this.buildForm(this.taskFilterProperties);
+            }
+            else {
+                this.retrieveTaskFilterAndBuildForm();
+            }
+        }
+    }
+    createFilterActions() {
+        return [
+            {
+                actionType: ACTION_SAVE,
+                icon: 'adf:save',
+                tooltip: 'ADF_CLOUD_EDIT_TASK_FILTER.TOOL_TIP.SAVE'
+            },
+            {
+                actionType: ACTION_SAVE_AS,
+                icon: 'adf:save-as',
+                tooltip: 'ADF_CLOUD_EDIT_TASK_FILTER.TOOL_TIP.SAVE_AS'
+            },
+            {
+                actionType: ACTION_DELETE,
+                icon: 'delete',
+                tooltip: 'ADF_CLOUD_EDIT_TASK_FILTER.TOOL_TIP.DELETE'
+            }
+        ];
+    }
+    hasFormChanged(action) {
+        if (action.actionType === ACTION_SAVE) {
+            return !this.formHasBeenChanged;
+        }
+        if (action.actionType === ACTION_SAVE_AS) {
+            return !this.formHasBeenChanged;
+        }
+        if (action.actionType === ACTION_DELETE) {
+            return false;
+        }
+        return false;
+    }
+    onExpand() {
+        this.toggleFilterActions = true;
+    }
+    onClose() {
+        this.toggleFilterActions = false;
+    }
+    isDisabledAction(action) {
+        return this.isDisabledForDefaultFilters(action) ? true : this.hasFormChanged(action);
+    }
+    deepCompare(left, right) {
+        return JSON.stringify(left).toLowerCase() === JSON.stringify(right).toLowerCase();
+    }
+    /**
+     * Get the sanitized filter name
+     *
+     * @param filterName filter name
+     * @returns sanitized filter name
+     */
+    getSanitizeFilterName(filterName) {
+        const nameWithHyphen = this.replaceSpaceWithHyphen(filterName.trim());
+        return nameWithHyphen.toLowerCase();
+    }
+    replaceSpaceWithHyphen(name) {
+        const regExt = new RegExp(' ', 'g');
+        return name.replace(regExt, '-');
+    }
+    executeFilterActions(action) {
+        if (action.actionType === ACTION_SAVE) {
+            this.save(action);
+        }
+        else if (action.actionType === ACTION_SAVE_AS) {
+            this.saveAs(action);
+        }
+        else if (action.actionType === ACTION_DELETE) {
+            this.delete(action);
+        }
+    }
+    getDeployedApplications() {
+        this.appsProcessCloudService.getDeployedApplicationsByStatus(APP_DEPLOYED_STATUS, this.role).subscribe((applications) => {
+            if (applications && applications.length > 0) {
+                applications.map((application) => {
+                    this.applicationNames.push({
+                        label: this.appsProcessCloudService.getApplicationLabel(application, this.environmentList),
+                        value: application.name
+                    });
+                });
+            }
+        });
+    }
+    getProcessDefinitions() {
+        this.taskCloudService.getProcessDefinitions(this.appName).subscribe((processDefinitions) => {
+            if (processDefinitions && processDefinitions.length > 0) {
+                this.processDefinitionNames.push(this.allProcessDefinitionNamesOption);
+                processDefinitions.map((processDefinition) => {
+                    this.processDefinitionNames.push({ label: processDefinition.name, value: processDefinition.name });
+                });
+            }
+        });
+    }
+    checkMandatoryActions() {
+        if (this.actions === undefined || this.actions.length === 0) {
+            this.actions = [...DEFAULT_ACTIONS];
+        }
+    }
+    isValidAction(actions, action) {
+        return actions ? actions.indexOf(action.actionType) >= 0 : true;
+    }
+    isFormValid() {
+        return this.editTaskFilterForm.valid;
+    }
+    getPropertyController(property) {
+        return this.editTaskFilterForm.get(property.key);
+    }
+    onDateChanged(newDateValue, dateProperty) {
+        if (newDateValue) {
+            let date;
+            if (typeof newDateValue === 'string') {
+                date = DateFnsUtils.parseDate(newDateValue, DATE_FORMAT);
+            }
+            else {
+                date = newDateValue;
+            }
+            const controller = this.getPropertyController(dateProperty);
+            if (isValid(date)) {
+                controller.setValue(date.toISOString());
+                controller.setErrors(null);
+            }
+            else {
+                controller.setErrors({ invalid: true });
+            }
+        }
+    }
+    onDateRangeFilterChanged(dateRange, property) {
+        this.editTaskFilterForm.get(property.attributes?.from).setValue(dateRange.startDate ? dateRange.startDate : null);
+        this.editTaskFilterForm.get(property.attributes?.to).setValue(dateRange.endDate ? dateRange.endDate : null);
+        this.editTaskFilterForm.get(property.attributes.dateType).setValue(DateCloudFilterType.RANGE);
+    }
+    onChangedUser(users, userProperty) {
+        let selectedUsers;
+        if (userProperty.selectionMode === 'single') {
+            selectedUsers = users[0];
+        }
+        else {
+            selectedUsers = users;
+        }
+        this.getPropertyController(userProperty).setValue(selectedUsers);
+    }
+    onAssignedUsersChange(assignedUsers) {
+        this.editTaskFilterForm.get('candidateGroups').setValue(undefined);
+        this.editTaskFilterForm.get('assignedUsers').setValue(assignedUsers);
+    }
+    onAssignedGroupsChange(groups) {
+        this.editTaskFilterForm.get('assignedUsers').setValue(undefined);
+        this.editTaskFilterForm.get('candidateGroups').setValue(groups);
+    }
+    onAssignmentTypeChange(assignmentType) {
+        switch (assignmentType) {
+            case AssignmentType.UNASSIGNED:
+                this.editTaskFilterForm.get('status').setValue(TaskStatusFilter.CREATED);
+                this.resetAssignmentTypeValues();
+                break;
+            case AssignmentType.NONE:
+                this.editTaskFilterForm.get('status').setValue(TaskStatusFilter.ALL);
+                this.resetAssignmentTypeValues();
+                break;
+            case AssignmentType.ASSIGNED_TO:
+            case AssignmentType.CANDIDATE_GROUPS:
+                this.editTaskFilterForm.get('status').setValue(TaskStatusFilter.ASSIGNED);
+                this.resetAssignmentTypeValues();
+                break;
+            default:
+                this.editTaskFilterForm.get('status').setValue(TaskStatusFilter.ASSIGNED);
+        }
+    }
+    onStatusChange(status) {
+        if (status.value === TaskStatusFilter.CREATED) {
+            this.resetAssignmentTypeValues();
+        }
+        this.selectedStatus = status.value;
+    }
+    resetAssignmentTypeValues() {
+        this.editTaskFilterForm.get('assignedUsers').setValue(undefined);
+        this.editTaskFilterForm.get('candidateGroups').setValue(undefined);
+    }
+    hasError(property) {
+        const controller = this.getPropertyController(property);
+        return !!controller.errors?.invalid;
+    }
+    hasLastModifiedProperty() {
+        return this.filterProperties.indexOf(LAST_MODIFIED_PROPERTY) >= 0;
+    }
+    get createSortProperties() {
+        this.checkMandatorySortProperties();
+        return this.sortProperties.map((property) => ({ label: property, value: property }));
+    }
+    createAndFilterActions() {
+        this.checkMandatoryActions();
+        return this.createFilterActions().filter((action) => this.isValidAction(this.actions, action));
+    }
+    isValidProperty(filterProperties, key) {
+        return filterProperties ? filterProperties.indexOf(key) >= 0 : true;
+    }
+    checkForProperty(property) {
+        return this.filterProperties ? this.filterProperties.indexOf(property) >= 0 : false;
+    }
+    hasSortProperty() {
+        return this.filterProperties.indexOf(SORT_PROPERTY) >= 0;
+    }
+    removeOrderProperty(filteredProperties) {
+        if (filteredProperties?.length > 0) {
+            return filteredProperties.filter((property) => property.key !== ORDER_PROPERTY);
+        }
+        return [];
+    }
+    createAndFilterProperties() {
+        this.checkMandatoryFilterProperties();
+        if (this.checkForProperty(APPLICATION_NAME)) {
+            this.applicationNames = [];
+            this.getDeployedApplications();
+        }
+        if (this.checkForProperty(PROCESS_DEFINITION_NAME)) {
+            this.processDefinitionNames = [];
+            this.getProcessDefinitions();
+        }
+        const defaultProperties = this.createTaskFilterProperties();
+        let filteredProperties = defaultProperties.filter((filterProperty) => this.isValidProperty(this.filterProperties, filterProperty.key));
+        if (!this.hasSortProperty()) {
+            filteredProperties = this.removeOrderProperty(filteredProperties);
+        }
+        return filteredProperties;
+    }
+    /**
+     * Check for edit task filter form changes
+     */
+    onFilterChange() {
+        this.editTaskFilterForm.valueChanges
+            .pipe(debounceTime(500), filter(() => this.isFormValid()), takeUntilDestroyed(this.destroyRef))
+            .subscribe((formValues) => {
+            this.assignNewFilter(formValues);
+        });
+    }
+    getFormControlsConfig(taskFilterProperties) {
+        const properties = taskFilterProperties.map((property) => {
+            if (property.attributes) {
+                return this.getAttributesControlConfig(property);
+            }
+            else {
+                return { [property.key]: property.value };
+            }
+        });
+        return properties.reduce((result, current) => Object.assign(result, current), {});
+    }
+    getAttributesControlConfig(property) {
+        return Object.values(property.attributes).reduce((result, key) => {
+            result[key] = property.value[key];
+            return result;
+        }, {});
+    }
+    buildForm(taskFilterProperties) {
+        this.formHasBeenChanged = false;
+        this.editTaskFilterForm = this.formBuilder.group(this.getFormControlsConfig(taskFilterProperties));
+        this.onFilterChange();
+    }
+    onDateTypeChange(dateType, property) {
+        this.editTaskFilterForm.get(property.attributes.dateType).setValue(dateType);
+    }
+    retrieveTaskFilterAndBuildForm() {
+        this.isLoading = true;
+        this.getTaskFilterById(this.appName, this.id)
+            .pipe(finalize(() => (this.isLoading = false)), takeUntilDestroyed(this.destroyRef))
+            .subscribe((response) => {
+            this.taskFilter = response;
+            this.taskFilterProperties = this.createAndFilterProperties();
+            this.taskFilterActions = this.createAndFilterActions();
+            this.buildForm(this.taskFilterProperties);
+        });
+    }
+    delete(deleteAction) {
+        this.deleteFilter(this.taskFilter)
+            .pipe(filter((filters) => {
+            deleteAction.filter = this.taskFilter;
+            this.action.emit(deleteAction);
+            return filters.length === 0;
+        }), switchMap(() => this.restoreDefaultTaskFilters()), takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => { });
+    }
+    save(saveAction) {
+        this.updateFilter(this.changedTaskFilter)
+            .pipe(takeUntilDestroyed(this.destroyRef))
+            .subscribe(() => {
+            saveAction.filter = this.changedTaskFilter;
+            this.action.emit(saveAction);
+            this.formHasBeenChanged = this.deepCompare(this.changedTaskFilter, this.taskFilter);
+        });
+    }
+    saveAs(saveAsAction) {
+        const dialogRef = this.dialog.open(TaskFilterDialogCloudComponent, {
+            data: {
+                name: this.translateService.instant(this.taskFilter?.name)
+            },
+            height: 'auto',
+            minWidth: '30%'
+        });
+        dialogRef.afterClosed().subscribe((result) => {
+            if (result && result.action === TaskFilterDialogCloudComponent.ACTION_SAVE) {
+                const filterId = Math.random().toString(36).substr(2, 9);
+                const filterKey = this.getSanitizeFilterName(result.name);
+                const newFilter = {
+                    name: result.name,
+                    icon: result.icon,
+                    id: filterId,
+                    key: 'custom-' + filterKey
+                };
+                const resultFilter = Object.assign({}, this.changedTaskFilter, newFilter);
+                this.addFilter(resultFilter).subscribe(() => {
+                    saveAsAction.filter = resultFilter;
+                    this.action.emit(saveAsAction);
+                });
+            }
+        });
+    }
+    checkMandatoryFilterProperties() {
+        if (this.filterProperties === undefined || this.filterProperties.length === 0) {
+            this.filterProperties = this.getDefaultFilterProperties();
+        }
+    }
+    checkMandatorySortProperties() {
+        if (this.sortProperties === undefined || this.sortProperties.length === 0) {
+            this.sortProperties = this.getDefaultSortProperties();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BaseEditTaskFilterCloudComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: BaseEditTaskFilterCloudComponent, inputs: { appName: "appName", id: "id", environmentList: "environmentList", processInstanceId: "processInstanceId", showTitle: "showTitle", showTaskFilterName: "showTaskFilterName", filterProperties: "filterProperties", role: "role", showFilterActions: "showFilterActions", actions: "actions", sortProperties: "sortProperties", taskFilter: "taskFilter" }, outputs: { action: "action", filterChange: "filterChange" }, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BaseEditTaskFilterCloudComponent, decorators: [{
+            type: Directive
+        }], propDecorators: { appName: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], environmentList: [{
+                type: Input
+            }], processInstanceId: [{
+                type: Input
+            }], showTitle: [{
+                type: Input
+            }], showTaskFilterName: [{
+                type: Input
+            }], filterProperties: [{
+                type: Input
+            }], role: [{
+                type: Input
+            }], showFilterActions: [{
+                type: Input
+            }], actions: [{
+                type: Input
+            }], sortProperties: [{
+                type: Input
+            }], action: [{
+                type: Output
+            }], taskFilter: [{
+                type: Input
+            }], filterChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-edit-task-filter-cloud.component.js","sourceRoot":"","sources":["../../../../../../../../../lib/process-services-cloud/src/lib/task/task-filters/components/edit-task-filters/base-edit-task-filter-cloud.component.ts"],"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 { DestroyRef, Directive, EventEmitter, inject, Input, OnChanges, OnInit, Output, SimpleChanges } from '@angular/core';\nimport { AssignmentType, FilterOptions, TaskFilterAction, TaskFilterProperties, TaskStatusFilter } from '../../models/filter-cloud.model';\nimport { TaskCloudService } from './../../../services/task-cloud.service';\nimport { AppsProcessCloudService } from './../../../../app/services/apps-process-cloud.service';\nimport { DateCloudFilterType, DateRangeFilter } from '../../../../models/date-cloud-filter.model';\nimport { AbstractControl, UntypedFormBuilder, UntypedFormGroup } from '@angular/forms';\nimport { debounceTime, filter, finalize, switchMap } from 'rxjs/operators';\nimport { Observable } from 'rxjs';\nimport { DateAdapter } from '@angular/material/core';\nimport { DateFnsUtils, TranslationService, UserPreferencesService, UserPreferenceValues } from '@alfresco/adf-core';\nimport { TaskFilterDialogCloudComponent } from '../task-filter-dialog/task-filter-dialog-cloud.component';\nimport { MatDialog } from '@angular/material/dialog';\nimport { IdentityUserModel } from '../../../../people/models/identity-user.model';\nimport { IdentityGroupModel } from '../../../../group/models/identity-group.model';\nimport { MatSelectChange } from '@angular/material/select';\nimport { Environment } from '../../../../common/interface/environment.interface';\nimport { isValid } from 'date-fns';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\n\n/* eslint-disable @typescript-eslint/naming-convention */\n\nexport interface DropdownOption {\n    value: string;\n    label: string;\n}\n\nconst ACTION_SAVE = 'save';\nconst ACTION_SAVE_AS = 'saveAs';\nconst ACTION_DELETE = 'delete';\nconst APP_DEPLOYED_STATUS = 'DEPLOYED';\nconst APPLICATION_NAME = 'appName';\nconst PROCESS_DEFINITION_NAME = 'processDefinitionName';\nconst LAST_MODIFIED_PROPERTY = 'lastModified';\nconst DATE_FORMAT = 'DD/MM/YYYY';\nconst DEFAULT_ACTIONS = [ACTION_SAVE, ACTION_SAVE_AS, ACTION_DELETE];\nconst SORT_PROPERTY = 'sort';\nconst ORDER_PROPERTY = 'order';\n\n@Directive()\n// eslint-disable-next-line @angular-eslint/directive-class-suffix\nexport abstract class BaseEditTaskFilterCloudComponent<T> implements OnInit, OnChanges {\n    public static ACTIONS_DISABLED_BY_DEFAULT = [ACTION_SAVE, ACTION_DELETE];\n\n    /** (required) Name of the app. */\n    @Input()\n    appName: string = '';\n\n    /** (required) ID of the task filter. */\n    @Input()\n    id: string;\n\n    /** List of environments. */\n    @Input()\n    environmentList: Environment[] = [];\n\n    /** processInstanceId of the task filter. */\n    @Input()\n    processInstanceId: string;\n\n    /** Toggles the title. */\n    @Input()\n    showTitle = true;\n\n    /** Toggles display of task filter name */\n    @Input()\n    showTaskFilterName = true;\n\n    /** List of task filter properties to display. */\n    @Input()\n    filterProperties: string[] = [];\n\n    /** user role. */\n    @Input()\n    role: string = '';\n\n    /** Toggles the filter actions. */\n    @Input()\n    showFilterActions = true;\n\n    /** List of task filter actions. */\n    @Input()\n    actions: string[] = [...DEFAULT_ACTIONS];\n\n    /** List of sort properties to display. */\n    @Input()\n    sortProperties: string[] = [];\n\n    /** Emitted when a filter action occurs (i.e Save, Save As, Delete). */\n    @Output()\n    action = new EventEmitter<TaskFilterAction>();\n\n    protected applicationNames: DropdownOption[] = [];\n    protected processDefinitionNames: DropdownOption[] = [];\n    protected formHasBeenChanged = false;\n\n    editTaskFilterForm: UntypedFormGroup;\n    taskFilterProperties: TaskFilterProperties[] = [];\n    taskFilterActions: TaskFilterAction[] = [];\n    toggleFilterActions: boolean = false;\n    selectedStatus: TaskStatusFilter;\n    sortDirections: DropdownOption[] = [\n        { value: 'ASC', label: 'ADF_CLOUD_TASK_FILTERS.DIRECTION.ASCENDING' },\n        { value: 'DESC', label: 'ADF_CLOUD_TASK_FILTERS.DIRECTION.DESCENDING' }\n    ];\n    allProcessDefinitionNamesOption: DropdownOption = {\n        value: '',\n        label: 'ADF_CLOUD_TASK_FILTERS.STATUS.ALL'\n    };\n\n    /** Task Filter to use. */\n    @Input()\n    taskFilter: T;\n\n    changedTaskFilter: T;\n\n    /** Emitted when a task filter property changes. */\n    @Output()\n    filterChange = new EventEmitter<T>();\n\n    isLoading: boolean = false;\n\n    protected destroyRef = inject(DestroyRef);\n    protected translateService = inject(TranslationService);\n    protected taskCloudService = inject(TaskCloudService);\n    protected userPreferencesService = inject(UserPreferencesService);\n    protected appsProcessCloudService = inject(AppsProcessCloudService);\n    protected dialog = inject(MatDialog);\n    protected formBuilder = inject(UntypedFormBuilder);\n    protected dateAdapter = inject<DateAdapter<Date>>(DateAdapter);\n\n    ngOnInit() {\n        this.userPreferencesService\n            .select(UserPreferenceValues.Locale)\n            .pipe(takeUntilDestroyed(this.destroyRef))\n            .subscribe((locale) => this.dateAdapter.setLocale(locale));\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        const { id } = changes;\n        if (id && id.currentValue !== id.previousValue) {\n            if (this.taskFilter && this.taskFilter['id'] === id.currentValue) {\n                this.taskFilterProperties = this.createAndFilterProperties();\n                this.taskFilterActions = this.createAndFilterActions();\n                this.buildForm(this.taskFilterProperties);\n            } else {\n                this.retrieveTaskFilterAndBuildForm();\n            }\n        }\n    }\n\n    createFilterActions(): TaskFilterAction[] {\n        return [\n            {\n                actionType: ACTION_SAVE,\n                icon: 'adf:save',\n                tooltip: 'ADF_CLOUD_EDIT_TASK_FILTER.TOOL_TIP.SAVE'\n            },\n            {\n                actionType: ACTION_SAVE_AS,\n                icon: 'adf:save-as',\n                tooltip: 'ADF_CLOUD_EDIT_TASK_FILTER.TOOL_TIP.SAVE_AS'\n            },\n            {\n                actionType: ACTION_DELETE,\n                icon: 'delete',\n                tooltip: 'ADF_CLOUD_EDIT_TASK_FILTER.TOOL_TIP.DELETE'\n            }\n        ];\n    }\n\n    hasFormChanged(action: TaskFilterAction): boolean {\n        if (action.actionType === ACTION_SAVE) {\n            return !this.formHasBeenChanged;\n        }\n        if (action.actionType === ACTION_SAVE_AS) {\n            return !this.formHasBeenChanged;\n        }\n        if (action.actionType === ACTION_DELETE) {\n            return false;\n        }\n\n        return false;\n    }\n\n    onExpand(): void {\n        this.toggleFilterActions = true;\n    }\n\n    onClose(): void {\n        this.toggleFilterActions = false;\n    }\n\n    isDisabledAction(action: TaskFilterAction): boolean {\n        return this.isDisabledForDefaultFilters(action) ? true : this.hasFormChanged(action);\n    }\n\n    protected deepCompare(left: any, right: any): boolean {\n        return JSON.stringify(left).toLowerCase() === JSON.stringify(right).toLowerCase();\n    }\n\n    /**\n     * Get the sanitized filter name\n     *\n     * @param filterName filter name\n     * @returns sanitized filter name\n     */\n    getSanitizeFilterName(filterName: string): string {\n        const nameWithHyphen = this.replaceSpaceWithHyphen(filterName.trim());\n        return nameWithHyphen.toLowerCase();\n    }\n\n    private replaceSpaceWithHyphen(name: string): string {\n        const regExt = new RegExp(' ', 'g');\n        return name.replace(regExt, '-');\n    }\n\n    executeFilterActions(action: TaskFilterAction): void {\n        if (action.actionType === ACTION_SAVE) {\n            this.save(action);\n        } else if (action.actionType === ACTION_SAVE_AS) {\n            this.saveAs(action);\n        } else if (action.actionType === ACTION_DELETE) {\n            this.delete(action);\n        }\n    }\n\n    getDeployedApplications() {\n        this.appsProcessCloudService.getDeployedApplicationsByStatus(APP_DEPLOYED_STATUS, this.role).subscribe((applications) => {\n            if (applications && applications.length > 0) {\n                applications.map((application) => {\n                    this.applicationNames.push({\n                        label: this.appsProcessCloudService.getApplicationLabel(application, this.environmentList),\n                        value: application.name\n                    });\n                });\n            }\n        });\n    }\n\n    getProcessDefinitions() {\n        this.taskCloudService.getProcessDefinitions(this.appName).subscribe((processDefinitions) => {\n            if (processDefinitions && processDefinitions.length > 0) {\n                this.processDefinitionNames.push(this.allProcessDefinitionNamesOption);\n                processDefinitions.map((processDefinition) => {\n                    this.processDefinitionNames.push({ label: processDefinition.name, value: processDefinition.name });\n                });\n            }\n        });\n    }\n\n    checkMandatoryActions(): void {\n        if (this.actions === undefined || this.actions.length === 0) {\n            this.actions = [...DEFAULT_ACTIONS];\n        }\n    }\n\n    private isValidAction(actions: string[], action: any): boolean {\n        return actions ? actions.indexOf(action.actionType) >= 0 : true;\n    }\n\n    isFormValid(): boolean {\n        return this.editTaskFilterForm.valid;\n    }\n\n    getPropertyController(property: TaskFilterProperties): AbstractControl {\n        return this.editTaskFilterForm.get(property.key);\n    }\n\n    onDateChanged(newDateValue: string | Date, dateProperty: TaskFilterProperties) {\n        if (newDateValue) {\n            let date: Date;\n\n            if (typeof newDateValue === 'string') {\n                date = DateFnsUtils.parseDate(newDateValue, DATE_FORMAT);\n            } else {\n                date = newDateValue;\n            }\n\n            const controller = this.getPropertyController(dateProperty);\n\n            if (isValid(date)) {\n                controller.setValue(date.toISOString());\n                controller.setErrors(null);\n            } else {\n                controller.setErrors({ invalid: true });\n            }\n        }\n    }\n\n    onDateRangeFilterChanged(dateRange: DateRangeFilter, property: TaskFilterProperties) {\n        this.editTaskFilterForm.get(property.attributes?.from).setValue(dateRange.startDate ? dateRange.startDate : null);\n        this.editTaskFilterForm.get(property.attributes?.to).setValue(dateRange.endDate ? dateRange.endDate : null);\n        this.editTaskFilterForm.get(property.attributes.dateType).setValue(DateCloudFilterType.RANGE);\n    }\n\n    onChangedUser(users: IdentityUserModel[], userProperty: TaskFilterProperties) {\n        let selectedUsers;\n        if (userProperty.selectionMode === 'single') {\n            selectedUsers = users[0];\n        } else {\n            selectedUsers = users;\n        }\n        this.getPropertyController(userProperty).setValue(selectedUsers);\n    }\n\n    onAssignedUsersChange(assignedUsers: IdentityUserModel[]) {\n        this.editTaskFilterForm.get('candidateGroups').setValue(undefined);\n        this.editTaskFilterForm.get('assignedUsers').setValue(assignedUsers);\n    }\n\n    onAssignedGroupsChange(groups: IdentityGroupModel[]) {\n        this.editTaskFilterForm.get('assignedUsers').setValue(undefined);\n        this.editTaskFilterForm.get('candidateGroups').setValue(groups);\n    }\n\n    onAssignmentTypeChange(assignmentType: AssignmentType) {\n        switch (assignmentType) {\n            case AssignmentType.UNASSIGNED:\n                this.editTaskFilterForm.get('status').setValue(TaskStatusFilter.CREATED);\n                this.resetAssignmentTypeValues();\n                break;\n            case AssignmentType.NONE:\n                this.editTaskFilterForm.get('status').setValue(TaskStatusFilter.ALL);\n                this.resetAssignmentTypeValues();\n                break;\n            case AssignmentType.ASSIGNED_TO:\n            case AssignmentType.CANDIDATE_GROUPS:\n                this.editTaskFilterForm.get('status').setValue(TaskStatusFilter.ASSIGNED);\n                this.resetAssignmentTypeValues();\n                break;\n            default:\n                this.editTaskFilterForm.get('status').setValue(TaskStatusFilter.ASSIGNED);\n        }\n    }\n\n    onStatusChange(status: MatSelectChange) {\n        if (status.value === TaskStatusFilter.CREATED) {\n            this.resetAssignmentTypeValues();\n        }\n\n        this.selectedStatus = status.value;\n    }\n\n    private resetAssignmentTypeValues() {\n        this.editTaskFilterForm.get('assignedUsers').setValue(undefined);\n        this.editTaskFilterForm.get('candidateGroups').setValue(undefined);\n    }\n\n    hasError(property: TaskFilterProperties): boolean {\n        const controller = this.getPropertyController(property);\n        return !!controller.errors?.invalid;\n    }\n\n    hasLastModifiedProperty(): boolean {\n        return this.filterProperties.indexOf(LAST_MODIFIED_PROPERTY) >= 0;\n    }\n\n    get createSortProperties(): FilterOptions[] {\n        this.checkMandatorySortProperties();\n\n        return this.sortProperties.map((property: string) => ({ label: property, value: property }));\n    }\n\n    createAndFilterActions(): TaskFilterAction[] {\n        this.checkMandatoryActions();\n        return this.createFilterActions().filter((action) => this.isValidAction(this.actions, action));\n    }\n\n    isValidProperty(filterProperties: string[], key: string): boolean {\n        return filterProperties ? filterProperties.indexOf(key) >= 0 : true;\n    }\n\n    checkForProperty(property: string): boolean {\n        return this.filterProperties ? this.filterProperties.indexOf(property) >= 0 : false;\n    }\n\n    hasSortProperty(): boolean {\n        return this.filterProperties.indexOf(SORT_PROPERTY) >= 0;\n    }\n\n    removeOrderProperty(filteredProperties: TaskFilterProperties[]): TaskFilterProperties[] {\n        if (filteredProperties?.length > 0) {\n            return filteredProperties.filter((property) => property.key !== ORDER_PROPERTY);\n        }\n        return [];\n    }\n\n    createAndFilterProperties() {\n        this.checkMandatoryFilterProperties();\n\n        if (this.checkForProperty(APPLICATION_NAME)) {\n            this.applicationNames = [];\n            this.getDeployedApplications();\n        }\n        if (this.checkForProperty(PROCESS_DEFINITION_NAME)) {\n            this.processDefinitionNames = [];\n            this.getProcessDefinitions();\n        }\n\n        const defaultProperties = this.createTaskFilterProperties();\n        let filteredProperties = defaultProperties.filter((filterProperty) => this.isValidProperty(this.filterProperties, filterProperty.key));\n\n        if (!this.hasSortProperty()) {\n            filteredProperties = this.removeOrderProperty(filteredProperties);\n        }\n\n        return filteredProperties;\n    }\n\n    /**\n     * Check for edit task filter form changes\n     */\n    onFilterChange() {\n        this.editTaskFilterForm.valueChanges\n            .pipe(\n                debounceTime(500),\n                filter(() => this.isFormValid()),\n                takeUntilDestroyed(this.destroyRef)\n            )\n            .subscribe((formValues) => {\n                this.assignNewFilter(formValues);\n            });\n    }\n\n    getFormControlsConfig(taskFilterProperties: TaskFilterProperties[]): any {\n        const properties = taskFilterProperties.map((property) => {\n            if (property.attributes) {\n                return this.getAttributesControlConfig(property);\n            } else {\n                return { [property.key]: property.value };\n            }\n        });\n        return properties.reduce((result, current) => Object.assign(result, current), {});\n    }\n\n    private getAttributesControlConfig(property: TaskFilterProperties) {\n        return Object.values(property.attributes).reduce((result, key) => {\n            result[key] = property.value[key];\n            return result;\n        }, {});\n    }\n\n    buildForm(taskFilterProperties: TaskFilterProperties[]) {\n        this.formHasBeenChanged = false;\n        this.editTaskFilterForm = this.formBuilder.group(this.getFormControlsConfig(taskFilterProperties));\n        this.onFilterChange();\n    }\n\n    onDateTypeChange(dateType: DateCloudFilterType, property: TaskFilterProperties) {\n        this.editTaskFilterForm.get(property.attributes.dateType).setValue(dateType);\n    }\n\n    protected retrieveTaskFilterAndBuildForm() {\n        this.isLoading = true;\n\n        this.getTaskFilterById(this.appName, this.id)\n            .pipe(\n                finalize(() => (this.isLoading = false)),\n                takeUntilDestroyed(this.destroyRef)\n            )\n            .subscribe((response) => {\n                this.taskFilter = response;\n                this.taskFilterProperties = this.createAndFilterProperties();\n                this.taskFilterActions = this.createAndFilterActions();\n                this.buildForm(this.taskFilterProperties);\n            });\n    }\n\n    delete(deleteAction: TaskFilterAction): void {\n        this.deleteFilter(this.taskFilter)\n            .pipe(\n                filter((filters) => {\n                    deleteAction.filter = this.taskFilter;\n                    this.action.emit(deleteAction);\n                    return filters.length === 0;\n                }),\n                switchMap(() => this.restoreDefaultTaskFilters()),\n                takeUntilDestroyed(this.destroyRef)\n            )\n            .subscribe(() => {});\n    }\n\n    save(saveAction: TaskFilterAction): void {\n        this.updateFilter(this.changedTaskFilter)\n            .pipe(takeUntilDestroyed(this.destroyRef))\n            .subscribe(() => {\n                saveAction.filter = this.changedTaskFilter;\n                this.action.emit(saveAction);\n                this.formHasBeenChanged = this.deepCompare(this.changedTaskFilter, this.taskFilter);\n            });\n    }\n\n    saveAs(saveAsAction: TaskFilterAction): void {\n        const dialogRef = this.dialog.open(TaskFilterDialogCloudComponent, {\n            data: {\n                name: this.translateService.instant((this.taskFilter as any)?.name)\n            },\n            height: 'auto',\n            minWidth: '30%'\n        });\n        dialogRef.afterClosed().subscribe((result) => {\n            if (result && result.action === TaskFilterDialogCloudComponent.ACTION_SAVE) {\n                const filterId = Math.random().toString(36).substr(2, 9);\n                const filterKey = this.getSanitizeFilterName(result.name);\n                const newFilter = {\n                    name: result.name,\n                    icon: result.icon,\n                    id: filterId,\n                    key: 'custom-' + filterKey\n                };\n                const resultFilter: T = Object.assign({}, this.changedTaskFilter, newFilter);\n                this.addFilter(resultFilter).subscribe(() => {\n                    saveAsAction.filter = resultFilter;\n                    this.action.emit(saveAsAction);\n                });\n            }\n        });\n    }\n\n    checkMandatoryFilterProperties() {\n        if (this.filterProperties === undefined || this.filterProperties.length === 0) {\n            this.filterProperties = this.getDefaultFilterProperties();\n        }\n    }\n\n    checkMandatorySortProperties(): void {\n        if (this.sortProperties === undefined || this.sortProperties.length === 0) {\n            this.sortProperties = this.getDefaultSortProperties();\n        }\n    }\n\n    abstract getDefaultFilterProperties(): string[];\n    abstract getDefaultSortProperties(): string[];\n    abstract isDisabledForDefaultFilters(action: TaskFilterAction): boolean;\n    abstract createTaskFilterProperties(): TaskFilterProperties[];\n    protected abstract getTaskFilterById(appName: string, id: string);\n    abstract assignNewFilter(formValues): void;\n\n    protected abstract restoreDefaultTaskFilters(): Observable<T[]>;\n    protected abstract addFilter(filterToAdd: T): Observable<any>;\n    protected abstract deleteFilter(filterToDelete: T): Observable<T[]>;\n    protected abstract updateFilter(filterToUpdate: T): Observable<any>;\n}\n"]}