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

package/esm2022/lib/task/task-filters/services/task-filter-cloud.service.mjs

@@ -0,0 +1,392 @@
+/*!
+ * @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 { Injectable, Inject } from '@angular/core';
+import { of, BehaviorSubject, throwError, Subject } from 'rxjs';
+import { TaskFilterCloudModel } from '../models/filter-cloud.model';
+import { switchMap, map } from 'rxjs/operators';
+import { BaseCloudService } from '../../../services/base-cloud.service';
+import { TASK_FILTERS_SERVICE_TOKEN } from '../../../services/cloud-token.service';
+import { NotificationCloudService } from '../../../services/notification-cloud.service';
+import { IdentityUserService } from '../../../people/services/identity-user.service';
+import { AdfHttpClient } from '@alfresco/adf-core/api';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../people/services/identity-user.service";
+import * as i2 from "../../../services/notification-cloud.service";
+import * as i3 from "@alfresco/adf-core/api";
+const TASK_EVENT_SUBSCRIPTION_QUERY = `
+    subscription {
+        engineEvents(eventType: [
+            TASK_COMPLETED
+            TASK_ASSIGNED
+            TASK_ACTIVATED
+            TASK_SUSPENDED
+            TASK_CANCELLED,
+            TASK_CREATED
+        ]) {
+            eventType
+            entity
+        }
+    }
+`;
+export class TaskFilterCloudService extends BaseCloudService {
+    constructor(identityUserService, preferenceService, notificationCloudService, adfHttpClient) {
+        super(adfHttpClient);
+        this.identityUserService = identityUserService;
+        this.preferenceService = preferenceService;
+        this.notificationCloudService = notificationCloudService;
+        this.filtersSubject = new BehaviorSubject([]);
+        this.filters$ = this.filtersSubject.asObservable();
+        this.filterKeyToBeRefreshedSource = new Subject();
+        this.filterKeyToBeRefreshed$ = this.filterKeyToBeRefreshedSource.asObservable();
+    }
+    /**
+     * Creates and returns the default task filters for an app.
+     *
+     * @param appName Name of the target app
+     */
+    createDefaultFilters(appName) {
+        const key = this.prepareKey(appName);
+        this.preferenceService
+            .getPreferences(appName, key)
+            .pipe(switchMap((response) => {
+            const preferences = response?.list?.entries || [];
+            if (!this.hasPreferences(preferences) || !this.hasTaskFilters(preferences, key)) {
+                return this.createTaskFilters(appName, key, this.defaultTaskFilters(appName));
+            }
+            else {
+                return of(this.findFiltersByKeyInPreferences(preferences, key));
+            }
+        }), switchMap((filters) => this.handleCreateFilterBackwardsCompatibility(appName, key, filters)))
+            .subscribe((filters) => {
+            this.addFiltersToStream(filters);
+        });
+    }
+    /**
+     * Checks user preference are empty or not
+     *
+     * @param preferences User preferences of the target app
+     * @returns Boolean value if the preferences are not empty
+     */
+    hasPreferences(preferences) {
+        return preferences && preferences.length > 0;
+    }
+    /**
+     * Checks for task filters in given user preferences
+     *
+     * @param preferences User preferences of the target app
+     * @param key Key of the task filters
+     * @returns Boolean value if the preference has task filters
+     */
+    hasTaskFilters(preferences, key) {
+        const filters = preferences.find((filter) => filter.entry.key === key);
+        return filters?.entry ? JSON.parse(filters.entry.value).length > 0 : false;
+    }
+    /**
+     * Calls create preference api to create task filters
+     *
+     * @param appName Name of the target app
+     * @param key Key of the task instance filters
+     * @param filters Details of new task filter
+     * @returns Observable of created task filters
+     */
+    createTaskFilters(appName, key, filters) {
+        return this.preferenceService.createPreference(appName, key, filters);
+    }
+    /**
+     * Calls get preference api to get task filter by preference key
+     *
+     * @param appName Name of the target app
+     * @param key Key of the task filters
+     * @returns Observable of task filters
+     */
+    getTaskFiltersByKey(appName, key) {
+        return this.preferenceService.getPreferenceByKey(appName, key);
+    }
+    /**
+     * Gets all task filters for a task app.
+     *
+     * @param appName Name of the target app
+     * @returns Observable of task filter details
+     */
+    getTaskListFilters(appName) {
+        this.createDefaultFilters(appName);
+        return this.filters$;
+    }
+    /**
+     * Gets a task filter.
+     *
+     * @param appName Name of the target app
+     * @param id ID of the task
+     * @returns Details of the task filter
+     */
+    getTaskFilterById(appName, id) {
+        const key = this.prepareKey(appName);
+        return this.getTaskFiltersByKey(appName, key).pipe(switchMap((filters) => {
+            if (filters && filters.length === 0) {
+                return this.createTaskFilters(appName, key, this.defaultTaskFilters(appName));
+            }
+            else {
+                return of(filters);
+            }
+        }), map((filters) => filters.filter((filter) => filter.id === id)[0]));
+    }
+    /**
+     * Adds a new task filter.
+     *
+     * @param newFilter The new filter to add
+     * @returns Observable of task instance filters with newly added filter
+     */
+    addFilter(newFilter) {
+        const key = this.prepareKey(newFilter.appName);
+        return this.getTaskFiltersByKey(newFilter.appName, key).pipe(switchMap((filters) => {
+            if (filters?.length === 0) {
+                return this.createTaskFilters(newFilter.appName, key, [newFilter]);
+            }
+            else {
+                filters.push(newFilter);
+                return this.preferenceService.updatePreference(newFilter.appName, key, filters);
+            }
+        }), map((filters) => {
+            this.addFiltersToStream(filters);
+            return filters;
+        }));
+    }
+    addFiltersToStream(filters) {
+        this.filtersSubject.next(filters);
+    }
+    /**
+     * Updates a task filter.
+     *
+     * @param updatedFilter The filter to update
+     * @returns Observable of task instance filters with updated filter
+     */
+    updateFilter(updatedFilter) {
+        const key = this.prepareKey(updatedFilter.appName);
+        return this.getTaskFiltersByKey(updatedFilter.appName, key).pipe(switchMap((filters) => {
+            if (filters?.length === 0) {
+                return this.createTaskFilters(updatedFilter.appName, key, [updatedFilter]);
+            }
+            else {
+                const itemIndex = filters.findIndex((filter) => filter.id === updatedFilter.id);
+                filters[itemIndex] = updatedFilter;
+                return this.updateTaskFilters(updatedFilter.appName, key, filters);
+            }
+        }), map((updatedFilters) => {
+            this.addFiltersToStream(updatedFilters);
+            return updatedFilters;
+        }));
+    }
+    /**
+     * Deletes a task filter
+     *
+     * @param deletedFilter The filter to delete
+     * @returns Observable of task instance filters without deleted filter
+     */
+    deleteFilter(deletedFilter) {
+        const key = this.prepareKey(deletedFilter.appName);
+        return this.getTaskFiltersByKey(deletedFilter.appName, key).pipe(switchMap((filters) => {
+            if (filters?.length > 0) {
+                filters = filters.filter((filter) => filter.id !== deletedFilter.id);
+                return this.updateTaskFilters(deletedFilter.appName, key, filters);
+            }
+            return of([]);
+        }), map((filters) => {
+            this.addFiltersToStream(filters);
+            return filters;
+        }));
+    }
+    /**
+     * Checks if given filter is a default filter
+     *
+     * @param filterName Name of the target task filter
+     * @returns Boolean value for whether the filter is a default filter
+     */
+    isDefaultFilter(filterName) {
+        const defaultFilters = this.defaultTaskFilters();
+        return defaultFilters.findIndex((filter) => filterName === filter.name) !== -1;
+    }
+    /**
+     * Finds a task using an object with optional query properties.
+     *
+     * @returns Task information
+     * @param taskFilter task filter model
+     */
+    getTaskFilterCounter(taskFilter) {
+        if (taskFilter.appName || taskFilter.appName === '') {
+            const queryUrl = `${this.getBasePath(taskFilter.appName)}/query/v1/tasks`;
+            const queryParams = {
+                processInstanceId: taskFilter.processInstanceId,
+                processDefinitionId: taskFilter.processDefinitionId,
+                processDefinitionName: taskFilter.processDefinitionName,
+                assignee: taskFilter.assignee,
+                status: taskFilter.status,
+                taskName: taskFilter.taskName,
+                appName: taskFilter.appName,
+                assignmentType: taskFilter.assignmentType,
+                owner: taskFilter.owner,
+                taskId: taskFilter.taskId,
+                parentTaskId: taskFilter.parentTaskId,
+                priority: taskFilter.priority,
+                lastModifiedFrom: taskFilter.lastModifiedFrom,
+                lastModifiedTo: taskFilter.lastModifiedTo,
+                standalone: taskFilter.standalone,
+                createdDate: taskFilter.createdDate,
+                completedDate: taskFilter.completedDate,
+                completedBy: taskFilter.completedBy,
+                dueDate: taskFilter.dueDate,
+                maxItems: 1
+            };
+            return this.get(queryUrl, queryParams).pipe(map((tasks) => tasks.list.pagination.totalItems));
+        }
+        else {
+            return throwError('Appname not configured');
+        }
+    }
+    /**
+     * Calls update preference api to update task filter
+     *
+     * @param appName Name of the target app
+     * @param key Key of the task filters
+     * @param filters Details of update filter
+     * @returns Observable of updated task filters
+     */
+    updateTaskFilters(appName, key, filters) {
+        return this.preferenceService.updatePreference(appName, key, filters);
+    }
+    /**
+     * Creates a uniq key with appName and username
+     *
+     * @param appName Name of the target app
+     * @returns String of task filters preference key
+     */
+    prepareKey(appName) {
+        return `task-filters-${appName}-${this.identityUserService.getCurrentUserInfo().username}`;
+    }
+    /**
+     * Finds and returns the task filters from preferences
+     *
+     * @returns Array of TaskFilterCloudModel
+     * @param preferences preferences
+     * @param key key
+     */
+    findFiltersByKeyInPreferences(preferences, key) {
+        const result = preferences.find((filter) => filter.entry.key === key);
+        return result?.entry ? JSON.parse(result.entry.value) : [];
+    }
+    /**
+     * Creates and returns the default filters for a task app.
+     *
+     * @param appName Name of the target app
+     * @returns Array of TaskFilterCloudModel
+     */
+    defaultTaskFilters(appName) {
+        return [
+            new TaskFilterCloudModel({
+                name: 'ADF_CLOUD_TASK_FILTERS.MY_TASKS',
+                key: 'my-tasks',
+                icon: 'inbox',
+                appName,
+                status: 'ASSIGNED',
+                assignee: this.identityUserService.getCurrentUserInfo().username,
+                sort: 'createdDate',
+                order: 'DESC',
+                showCounter: true
+            }),
+            new TaskFilterCloudModel({
+                name: 'ADF_CLOUD_TASK_FILTERS.QUEUED_TASKS',
+                key: 'queued-tasks',
+                icon: 'queue',
+                appName,
+                status: 'CREATED',
+                assignee: '',
+                sort: 'createdDate',
+                order: 'DESC',
+                showCounter: true
+            }),
+            new TaskFilterCloudModel({
+                name: 'ADF_CLOUD_TASK_FILTERS.COMPLETED_TASKS',
+                key: 'completed-tasks',
+                icon: 'done',
+                appName,
+                status: 'COMPLETED',
+                assignee: '',
+                sort: 'createdDate',
+                order: 'DESC'
+            })
+        ];
+    }
+    getTaskNotificationSubscription(appName) {
+        return this.notificationCloudService
+            .makeGQLQuery(appName, TASK_EVENT_SUBSCRIPTION_QUERY)
+            .pipe(map((events) => events.data.engineEvents));
+    }
+    /**
+     * Refresh filter key
+     *
+     * @param filterKey  Key of the filter
+     */
+    refreshFilter(filterKey) {
+        this.filterKeyToBeRefreshedSource.next(filterKey);
+    }
+    /**
+     * This method is run after retrieving the filter array from preferences.
+     * It handles the backwards compatibility with the new API by looking for the new properties and their counterparts in each passed filter.
+     * If the new property is not found, it is created and assigned the value constructed from the old property.
+     * The filters are then updated in the preferences and returned.
+     * Old properties are left untouched for purposes like feature toggling.
+     *
+     * @param appName Name of the target app.
+     * @param key Key of the task filters.
+     * @param filters Array of task filters to be checked for backward compatibility.
+     * @returns Observable of task filters with updated properties.
+     */
+    handleCreateFilterBackwardsCompatibility(appName, key, filters) {
+        filters.forEach((filter) => {
+            if (filter.taskName && !filter.taskNames) {
+                filter.taskNames = [filter.taskName];
+            }
+            if (filter.status && !filter.statuses) {
+                filter.statuses = [filter.status];
+            }
+            if (filter.assignee && !filter.assignees) {
+                filter.assignees = [filter.assignee];
+            }
+            if (filter.processDefinitionName && !filter.processDefinitionNames) {
+                filter.processDefinitionNames = [filter.processDefinitionName];
+            }
+            if (filter.completedBy?.username && !filter.completedByUsers) {
+                filter.completedByUsers = [filter.completedBy.username];
+            }
+            if (filter.priority && !filter.priorities) {
+                filter.priorities = [`${filter.priority}`];
+            }
+        });
+        return this.updateTaskFilters(appName, key, filters);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TaskFilterCloudService, deps: [{ token: i1.IdentityUserService }, { token: TASK_FILTERS_SERVICE_TOKEN }, { token: i2.NotificationCloudService }, { token: i3.AdfHttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TaskFilterCloudService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TaskFilterCloudService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.IdentityUserService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TASK_FILTERS_SERVICE_TOKEN]
+                }] }, { type: i2.NotificationCloudService }, { type: i3.AdfHttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-filter-cloud.service.js","sourceRoot":"","sources":["../../../../../../../../lib/process-services-cloud/src/lib/task/task-filters/services/task-filter-cloud.service.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 { Injectable, Inject } from '@angular/core';\nimport { Observable, of, BehaviorSubject, throwError, Subject } from 'rxjs';\nimport { TaskFilterCloudModel } from '../models/filter-cloud.model';\nimport { switchMap, map } from 'rxjs/operators';\nimport { BaseCloudService } from '../../../services/base-cloud.service';\nimport { PreferenceCloudServiceInterface } from '../../../services/preference-cloud.interface';\nimport { TASK_FILTERS_SERVICE_TOKEN } from '../../../services/cloud-token.service';\nimport { TaskCloudNodePaging } from '../../../models/task-cloud.model';\nimport { NotificationCloudService } from '../../../services/notification-cloud.service';\nimport { TaskCloudEngineEvent } from '../../../models/engine-event-cloud.model';\nimport { IdentityUserService } from '../../../people/services/identity-user.service';\nimport { AdfHttpClient } from '@alfresco/adf-core/api';\n\nconst TASK_EVENT_SUBSCRIPTION_QUERY = `\n    subscription {\n        engineEvents(eventType: [\n            TASK_COMPLETED\n            TASK_ASSIGNED\n            TASK_ACTIVATED\n            TASK_SUSPENDED\n            TASK_CANCELLED,\n            TASK_CREATED\n        ]) {\n            eventType\n            entity\n        }\n    }\n`;\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class TaskFilterCloudService extends BaseCloudService {\n    private filtersSubject = new BehaviorSubject<TaskFilterCloudModel[]>([]);\n    filters$ = this.filtersSubject.asObservable();\n    private filterKeyToBeRefreshedSource = new Subject<string>();\n    filterKeyToBeRefreshed$ = this.filterKeyToBeRefreshedSource.asObservable();\n\n    constructor(\n        private identityUserService: IdentityUserService,\n        @Inject(TASK_FILTERS_SERVICE_TOKEN)\n        public preferenceService: PreferenceCloudServiceInterface,\n        private notificationCloudService: NotificationCloudService,\n        adfHttpClient: AdfHttpClient\n    ) {\n        super(adfHttpClient);\n    }\n\n    /**\n     * Creates and returns the default task filters for an app.\n     *\n     * @param appName Name of the target app\n     */\n    private createDefaultFilters(appName: string): void {\n        const key: string = this.prepareKey(appName);\n        this.preferenceService\n            .getPreferences(appName, key)\n            .pipe(\n                switchMap((response) => {\n                    const preferences = response?.list?.entries || [];\n                    if (!this.hasPreferences(preferences) || !this.hasTaskFilters(preferences, key)) {\n                        return this.createTaskFilters(appName, key, this.defaultTaskFilters(appName));\n                    } else {\n                        return of(this.findFiltersByKeyInPreferences(preferences, key));\n                    }\n                }),\n                switchMap((filters) => this.handleCreateFilterBackwardsCompatibility(appName, key, filters))\n            )\n            .subscribe((filters) => {\n                this.addFiltersToStream(filters);\n            });\n    }\n\n    /**\n     * Checks user preference are empty or not\n     *\n     * @param preferences User preferences of the target app\n     * @returns Boolean value if the preferences are not empty\n     */\n    private hasPreferences(preferences: any): boolean {\n        return preferences && preferences.length > 0;\n    }\n\n    /**\n     * Checks for task filters in given user preferences\n     *\n     * @param preferences User preferences of the target app\n     * @param key Key of the task filters\n     * @returns Boolean value if the preference has task filters\n     */\n    private hasTaskFilters(preferences: any, key: string): boolean {\n        const filters = preferences.find((filter: any) => filter.entry.key === key);\n        return filters?.entry ? JSON.parse(filters.entry.value).length > 0 : false;\n    }\n\n    /**\n     * Calls create preference api to create task filters\n     *\n     * @param appName Name of the target app\n     * @param key Key of the task instance filters\n     * @param filters Details of new task filter\n     * @returns Observable of created task filters\n     */\n    private createTaskFilters(appName: string, key: string, filters: TaskFilterCloudModel[]): Observable<TaskFilterCloudModel[]> {\n        return this.preferenceService.createPreference(appName, key, filters);\n    }\n\n    /**\n     * Calls get preference api to get task filter by preference key\n     *\n     * @param appName Name of the target app\n     * @param key Key of the task filters\n     * @returns Observable of task filters\n     */\n    private getTaskFiltersByKey(appName: string, key: string): Observable<TaskFilterCloudModel[]> {\n        return this.preferenceService.getPreferenceByKey(appName, key);\n    }\n\n    /**\n     * Gets all task filters for a task app.\n     *\n     * @param appName Name of the target app\n     * @returns Observable of task filter details\n     */\n    getTaskListFilters(appName?: string): Observable<TaskFilterCloudModel[]> {\n        this.createDefaultFilters(appName);\n        return this.filters$;\n    }\n\n    /**\n     * Gets a task filter.\n     *\n     * @param appName Name of the target app\n     * @param id ID of the task\n     * @returns Details of the task filter\n     */\n    getTaskFilterById(appName: string, id: string): Observable<TaskFilterCloudModel> {\n        const key: string = this.prepareKey(appName);\n        return this.getTaskFiltersByKey(appName, key).pipe(\n            switchMap((filters) => {\n                if (filters && filters.length === 0) {\n                    return this.createTaskFilters(appName, key, this.defaultTaskFilters(appName));\n                } else {\n                    return of(filters);\n                }\n            }),\n            map((filters) => filters.filter((filter) => filter.id === id)[0])\n        );\n    }\n\n    /**\n     * Adds a new task filter.\n     *\n     * @param newFilter The new filter to add\n     * @returns Observable of task instance filters with newly added filter\n     */\n    addFilter(newFilter: TaskFilterCloudModel): Observable<TaskFilterCloudModel[]> {\n        const key: string = this.prepareKey(newFilter.appName);\n        return this.getTaskFiltersByKey(newFilter.appName, key).pipe(\n            switchMap((filters) => {\n                if (filters?.length === 0) {\n                    return this.createTaskFilters(newFilter.appName, key, [newFilter]);\n                } else {\n                    filters.push(newFilter);\n                    return this.preferenceService.updatePreference(newFilter.appName, key, filters);\n                }\n            }),\n            map((filters) => {\n                this.addFiltersToStream(filters);\n                return filters;\n            })\n        );\n    }\n\n    private addFiltersToStream(filters: TaskFilterCloudModel[]) {\n        this.filtersSubject.next(filters);\n    }\n\n    /**\n     * Updates a task filter.\n     *\n     * @param updatedFilter The filter to update\n     * @returns Observable of task instance filters with updated filter\n     */\n    updateFilter(updatedFilter: TaskFilterCloudModel): Observable<TaskFilterCloudModel[]> {\n        const key: string = this.prepareKey(updatedFilter.appName);\n        return this.getTaskFiltersByKey(updatedFilter.appName, key).pipe(\n            switchMap((filters) => {\n                if (filters?.length === 0) {\n                    return this.createTaskFilters(updatedFilter.appName, key, [updatedFilter]);\n                } else {\n                    const itemIndex = filters.findIndex((filter) => filter.id === updatedFilter.id);\n                    filters[itemIndex] = updatedFilter;\n                    return this.updateTaskFilters(updatedFilter.appName, key, filters);\n                }\n            }),\n            map((updatedFilters) => {\n                this.addFiltersToStream(updatedFilters);\n                return updatedFilters;\n            })\n        );\n    }\n\n    /**\n     * Deletes a task filter\n     *\n     * @param deletedFilter The filter to delete\n     * @returns Observable of task instance filters without deleted filter\n     */\n    deleteFilter(deletedFilter: TaskFilterCloudModel): Observable<TaskFilterCloudModel[]> {\n        const key = this.prepareKey(deletedFilter.appName);\n        return this.getTaskFiltersByKey(deletedFilter.appName, key).pipe(\n            switchMap((filters) => {\n                if (filters?.length > 0) {\n                    filters = filters.filter((filter) => filter.id !== deletedFilter.id);\n                    return this.updateTaskFilters(deletedFilter.appName, key, filters);\n                }\n                return of([]);\n            }),\n            map((filters) => {\n                this.addFiltersToStream(filters);\n                return filters;\n            })\n        );\n    }\n\n    /**\n     * Checks if given filter is a default filter\n     *\n     * @param filterName Name of the target task filter\n     * @returns Boolean value for whether the filter is a default filter\n     */\n    isDefaultFilter(filterName: string): boolean {\n        const defaultFilters = this.defaultTaskFilters();\n        return defaultFilters.findIndex((filter) => filterName === filter.name) !== -1;\n    }\n\n    /**\n     * Finds a task using an object with optional query properties.\n     *\n     * @returns Task information\n     * @param taskFilter task filter model\n     */\n    getTaskFilterCounter(taskFilter: TaskFilterCloudModel): Observable<number> {\n        if (taskFilter.appName || taskFilter.appName === '') {\n            const queryUrl = `${this.getBasePath(taskFilter.appName)}/query/v1/tasks`;\n            const queryParams = {\n                processInstanceId: taskFilter.processInstanceId,\n                processDefinitionId: taskFilter.processDefinitionId,\n                processDefinitionName: taskFilter.processDefinitionName,\n                assignee: taskFilter.assignee,\n                status: taskFilter.status,\n                taskName: taskFilter.taskName,\n                appName: taskFilter.appName,\n                assignmentType: taskFilter.assignmentType,\n                owner: taskFilter.owner,\n                taskId: taskFilter.taskId,\n                parentTaskId: taskFilter.parentTaskId,\n                priority: taskFilter.priority,\n                lastModifiedFrom: taskFilter.lastModifiedFrom,\n                lastModifiedTo: taskFilter.lastModifiedTo,\n                standalone: taskFilter.standalone,\n                createdDate: taskFilter.createdDate,\n                completedDate: taskFilter.completedDate,\n                completedBy: taskFilter.completedBy,\n                dueDate: taskFilter.dueDate,\n                maxItems: 1\n            };\n            return this.get<TaskCloudNodePaging>(queryUrl, queryParams).pipe(map((tasks) => tasks.list.pagination.totalItems));\n        } else {\n            return throwError('Appname not configured');\n        }\n    }\n\n    /**\n     * Calls update preference api to update task filter\n     *\n     * @param appName Name of the target app\n     * @param key Key of the task filters\n     * @param filters Details of update filter\n     * @returns Observable of updated task filters\n     */\n    private updateTaskFilters(appName: string, key: string, filters: TaskFilterCloudModel[]): Observable<TaskFilterCloudModel[]> {\n        return this.preferenceService.updatePreference(appName, key, filters);\n    }\n\n    /**\n     * Creates a uniq key with appName and username\n     *\n     * @param appName Name of the target app\n     * @returns String of task filters preference key\n     */\n    private prepareKey(appName: string): string {\n        return `task-filters-${appName}-${this.identityUserService.getCurrentUserInfo().username}`;\n    }\n\n    /**\n     * Finds and returns the task filters from preferences\n     *\n     * @returns Array of TaskFilterCloudModel\n     * @param preferences preferences\n     * @param key key\n     */\n    private findFiltersByKeyInPreferences(preferences: any, key: string): TaskFilterCloudModel[] {\n        const result = preferences.find((filter: any) => filter.entry.key === key);\n        return result?.entry ? JSON.parse(result.entry.value) : [];\n    }\n\n    /**\n     * Creates and returns the default filters for a task app.\n     *\n     * @param appName Name of the target app\n     * @returns Array of TaskFilterCloudModel\n     */\n    private defaultTaskFilters(appName?: string): TaskFilterCloudModel[] {\n        return [\n            new TaskFilterCloudModel({\n                name: 'ADF_CLOUD_TASK_FILTERS.MY_TASKS',\n                key: 'my-tasks',\n                icon: 'inbox',\n                appName,\n                status: 'ASSIGNED',\n                assignee: this.identityUserService.getCurrentUserInfo().username,\n                sort: 'createdDate',\n                order: 'DESC',\n                showCounter: true\n            }),\n            new TaskFilterCloudModel({\n                name: 'ADF_CLOUD_TASK_FILTERS.QUEUED_TASKS',\n                key: 'queued-tasks',\n                icon: 'queue',\n                appName,\n                status: 'CREATED',\n                assignee: '',\n                sort: 'createdDate',\n                order: 'DESC',\n                showCounter: true\n            }),\n            new TaskFilterCloudModel({\n                name: 'ADF_CLOUD_TASK_FILTERS.COMPLETED_TASKS',\n                key: 'completed-tasks',\n                icon: 'done',\n                appName,\n                status: 'COMPLETED',\n                assignee: '',\n                sort: 'createdDate',\n                order: 'DESC'\n            })\n        ];\n    }\n\n    getTaskNotificationSubscription(appName: string): Observable<TaskCloudEngineEvent[]> {\n        return this.notificationCloudService\n            .makeGQLQuery(appName, TASK_EVENT_SUBSCRIPTION_QUERY)\n            .pipe(map((events: any) => events.data.engineEvents));\n    }\n\n    /**\n     * Refresh filter key\n     *\n     * @param filterKey  Key of the filter\n     */\n    refreshFilter(filterKey: string): void {\n        this.filterKeyToBeRefreshedSource.next(filterKey);\n    }\n\n    /**\n     * This method is run after retrieving the filter array from preferences.\n     * It handles the backwards compatibility with the new API by looking for the new properties and their counterparts in each passed filter.\n     * If the new property is not found, it is created and assigned the value constructed from the old property.\n     * The filters are then updated in the preferences and returned.\n     * Old properties are left untouched for purposes like feature toggling.\n     *\n     * @param appName Name of the target app.\n     * @param key Key of the task filters.\n     * @param filters Array of task filters to be checked for backward compatibility.\n     * @returns Observable of task filters with updated properties.\n     */\n    private handleCreateFilterBackwardsCompatibility(\n        appName: string,\n        key: string,\n        filters: TaskFilterCloudModel[]\n    ): Observable<TaskFilterCloudModel[]> {\n        filters.forEach((filter) => {\n            if (filter.taskName && !filter.taskNames) {\n                filter.taskNames = [filter.taskName];\n            }\n            if (filter.status && !filter.statuses) {\n                filter.statuses = [filter.status];\n            }\n            if (filter.assignee && !filter.assignees) {\n                filter.assignees = [filter.assignee];\n            }\n            if (filter.processDefinitionName && !filter.processDefinitionNames) {\n                filter.processDefinitionNames = [filter.processDefinitionName];\n            }\n            if (filter.completedBy?.username && !filter.completedByUsers) {\n                filter.completedByUsers = [filter.completedBy.username];\n            }\n            if (filter.priority && !filter.priorities) {\n                filter.priorities = [`${filter.priority}`];\n            }\n        });\n\n        return this.updateTaskFilters(appName, key, filters);\n    }\n}\n"]}

package/esm2022/lib/task/task-filters/task-filters-cloud.module.mjs

@@ -0,0 +1,56 @@
+/*!
+ * @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 { NgModule } from '@angular/core';
+import { TaskFiltersCloudComponent } from './components/task-filters/task-filters-cloud.component';
+import { EditServiceTaskFilterCloudComponent } from './components/edit-task-filters/edit-service-task-filter/edit-service-task-filter-cloud.component';
+import { EditTaskFilterCloudComponent } from './components/edit-task-filters/edit-task-filter/edit-task-filter-cloud.component';
+import { TaskFilterDialogCloudComponent } from './components/task-filter-dialog/task-filter-dialog-cloud.component';
+import { ServiceTaskFiltersCloudComponent } from './components/service-task-filters/service-task-filters-cloud.component';
+import { TaskAssignmentFilterCloudComponent } from './components/task-assignment-filter/task-assignment-filter.component';
+import * as i0 from "@angular/core";
+export const TASK_FILTERS_CLOUD_DIRECTIVES = [
+    TaskFilterDialogCloudComponent,
+    TaskFiltersCloudComponent,
+    ServiceTaskFiltersCloudComponent,
+    EditTaskFilterCloudComponent,
+    TaskAssignmentFilterCloudComponent,
+    EditServiceTaskFilterCloudComponent
+];
+/** @deprecated use ...TASK_FILTERS_CLOUD_DIRECTIVES instead */
+export class TaskFiltersCloudModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TaskFiltersCloudModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: TaskFiltersCloudModule, imports: [TaskFilterDialogCloudComponent,
+            TaskFiltersCloudComponent,
+            ServiceTaskFiltersCloudComponent,
+            EditTaskFilterCloudComponent,
+            TaskAssignmentFilterCloudComponent,
+            EditServiceTaskFilterCloudComponent], exports: [TaskFilterDialogCloudComponent,
+            TaskFiltersCloudComponent,
+            ServiceTaskFiltersCloudComponent,
+            EditTaskFilterCloudComponent,
+            TaskAssignmentFilterCloudComponent,
+            EditServiceTaskFilterCloudComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TaskFiltersCloudModule, imports: [TASK_FILTERS_CLOUD_DIRECTIVES] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TaskFiltersCloudModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [...TASK_FILTERS_CLOUD_DIRECTIVES],
+                    exports: [...TASK_FILTERS_CLOUD_DIRECTIVES]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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