@valtimo/task 11.3.2 → 12.1.0

package/esm2022/lib/services/task-list-search.service.mjs

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2015-2024 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * 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 } from '@angular/core';
+import { BehaviorSubject, map, of, switchMap, tap } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@valtimo/config";
+import * as i2 from "./task-list.service";
+import * as i3 from "./task.service";
+export class TaskListSearchService {
+    get loadingSearchFields$() {
+        return this._loadingSearchFields$.asObservable();
+    }
+    get otherFilters$() {
+        return this._otherFilters$.asObservable();
+    }
+    constructor(configService, taskListService, taskService) {
+        this.configService = configService;
+        this.taskListService = taskListService;
+        this.taskService = taskService;
+        this._loadingSearchFields$ = new BehaviorSubject(true);
+        this._otherFilters$ = new BehaviorSubject([]);
+        this.searchFields$ = this.taskListService.caseDefinitionName$.pipe(tap(() => this._loadingSearchFields$.next(true)), switchMap(caseDefinitionName => caseDefinitionName
+            ? this.taskService.getTaskListSearchFields(caseDefinitionName)
+            : of([])), map(searchFields => searchFields.map(searchField => {
+            const fieldTypeLowerCase = searchField.fieldType?.toLowerCase();
+            return {
+                ...searchField,
+                dataType: searchField.dataType?.toLowerCase(),
+                fieldType: fieldTypeLowerCase === 'text_contains' ? 'single' : fieldTypeLowerCase,
+                matchType: searchField?.matchType?.toLowerCase(),
+            };
+        })), tap(() => this._loadingSearchFields$.next(false)));
+    }
+    setSearchFieldValues(searchFieldValues) {
+        this._otherFilters$.next(this.mapSearchValuesToFilters(searchFieldValues));
+    }
+    setOtherFilters(otherFilters) {
+        this._otherFilters$.next(otherFilters);
+    }
+    resetOtherFilters() {
+        this._otherFilters$.next([]);
+    }
+    mapOtherFilterToSearchValues(otherFilters) {
+        return otherFilters.reduce((acc, curr) => {
+            const filter = curr;
+            if (filter.rangeFrom) {
+                return {
+                    ...acc,
+                    [filter.key]: {
+                        start: filter.rangeFrom,
+                        end: filter.rangeTo,
+                    },
+                };
+            }
+            else if (filter.multiValue) {
+                return { ...acc, [filter.key]: filter.values };
+            }
+            else if (Array.isArray(filter.values) && filter.values.length > 0 && !filter.multiValue) {
+                return { ...acc, [filter.key]: filter.values[0] };
+            }
+            return acc;
+        }, {});
+    }
+    mapSearchValuesToFilters(values) {
+        const filters = [];
+        Object.keys(values).forEach(valueKey => {
+            const searchValue = values[valueKey];
+            if (searchValue.start) {
+                filters.push({ key: valueKey, rangeFrom: searchValue.start, rangeTo: searchValue.end });
+            }
+            else if (Array.isArray(searchValue)) {
+                filters.push({ key: valueKey, values: searchValue, multiValue: true });
+            }
+            else {
+                filters.push({ key: valueKey, values: [searchValue], multiValue: false });
+            }
+        });
+        return filters;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListSearchService, deps: [{ token: i1.ConfigService }, { token: i2.TaskListService }, { token: i3.TaskService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListSearchService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListSearchService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.ConfigService }, { type: i2.TaskListService }, { type: i3.TaskService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-list-search.service.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/task/src/lib/services/task-list-search.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2024 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (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 * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\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} from '@angular/core';\nimport {\n  ConfigService,\n  SearchField,\n  SearchFieldValues,\n  SearchFilter,\n  SearchFilterRange,\n} from '@valtimo/config';\nimport {BehaviorSubject, map, Observable, of, switchMap, tap} from 'rxjs';\nimport {TaskListService} from './task-list.service';\nimport {TaskListOtherFilters, TaskListSearchField} from '../models';\nimport {TaskService} from './task.service';\n\n@Injectable()\nexport class TaskListSearchService {\n  private readonly _loadingSearchFields$ = new BehaviorSubject<boolean>(true);\n  private readonly _otherFilters$ = new BehaviorSubject<TaskListOtherFilters>([]);\n\n  public get loadingSearchFields$(): Observable<boolean> {\n    return this._loadingSearchFields$.asObservable();\n  }\n\n  public get otherFilters$(): Observable<TaskListOtherFilters> {\n    return this._otherFilters$.asObservable();\n  }\n\n  public readonly searchFields$: Observable<SearchField[]> =\n    this.taskListService.caseDefinitionName$.pipe(\n      tap(() => this._loadingSearchFields$.next(true)),\n      switchMap(caseDefinitionName =>\n        caseDefinitionName\n          ? this.taskService.getTaskListSearchFields(caseDefinitionName)\n          : of([] as TaskListSearchField[])\n      ),\n      map(searchFields =>\n        searchFields.map(searchField => {\n          const fieldTypeLowerCase = searchField.fieldType?.toLowerCase();\n\n          return {\n            ...searchField,\n            dataType: searchField.dataType?.toLowerCase(),\n            fieldType: fieldTypeLowerCase === 'text_contains' ? 'single' : fieldTypeLowerCase,\n            matchType: searchField?.matchType?.toLowerCase(),\n          } as unknown as SearchField;\n        })\n      ),\n      tap(() => this._loadingSearchFields$.next(false))\n    );\n\n  constructor(\n    private readonly configService: ConfigService,\n    private readonly taskListService: TaskListService,\n    private readonly taskService: TaskService\n  ) {}\n\n  public setSearchFieldValues(searchFieldValues: SearchFieldValues): void {\n    this._otherFilters$.next(this.mapSearchValuesToFilters(searchFieldValues));\n  }\n\n  public setOtherFilters(otherFilters: TaskListOtherFilters): void {\n    this._otherFilters$.next(otherFilters);\n  }\n\n  public resetOtherFilters(): void {\n    this._otherFilters$.next([]);\n  }\n\n  public mapOtherFilterToSearchValues(otherFilters: TaskListOtherFilters): SearchFieldValues {\n    return otherFilters.reduce((acc, curr) => {\n      const filter = curr as any;\n\n      if (filter.rangeFrom) {\n        return {\n          ...acc,\n          [filter.key]: {\n            start: filter.rangeFrom,\n            end: filter.rangeTo,\n          },\n        };\n      } else if (filter.multiValue) {\n        return {...acc, [filter.key]: filter.values};\n      } else if (Array.isArray(filter.values) && filter.values.length > 0 && !filter.multiValue) {\n        return {...acc, [filter.key]: filter.values[0]};\n      }\n\n      return acc;\n    }, {});\n  }\n\n  private mapSearchValuesToFilters(values: SearchFieldValues): TaskListOtherFilters {\n    const filters: Array<SearchFilter | SearchFilterRange> = [];\n\n    Object.keys(values).forEach(valueKey => {\n      const searchValue = values[valueKey] as any;\n      if (searchValue.start) {\n        filters.push({key: valueKey, rangeFrom: searchValue.start, rangeTo: searchValue.end});\n      } else if (Array.isArray(searchValue)) {\n        filters.push({key: valueKey, values: searchValue, multiValue: true});\n      } else {\n        filters.push({key: valueKey, values: [searchValue], multiValue: false});\n      }\n    });\n\n    return filters;\n  }\n}\n"]}

package/esm2022/lib/services/task-list-sort.service.mjs

@@ -0,0 +1,116 @@
+/*
+ * Copyright 2015-2024 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * 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 } from '@angular/core';
+import { BehaviorSubject, combineLatest } from 'rxjs';
+import { TaskListTab } from '@valtimo/config';
+import { map, take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./task.service";
+import * as i2 from "./task-list.service";
+export class TaskListSortService {
+    get sortStateForCurrentTaskType$() {
+        return this._sortStateForCurrentTaskType$;
+    }
+    get sortStringForCurrentTaskType$() {
+        return this.sortStateForCurrentTaskType$.pipe(map(sortState => (sortState ? this.getSortString(sortState) : null)));
+    }
+    get overrideSortState$() {
+        return this._overrideSortState$.asObservable();
+    }
+    get overrideSortStateString$() {
+        return this._overrideSortState$.pipe(map(state => (state ? this.getSortString(state) : null)));
+    }
+    get _defaultSortState() {
+        return this.taskService.getConfigCustomTaskList()?.defaultSortedColumn || null;
+    }
+    constructor(taskService, taskListService) {
+        this.taskService = taskService;
+        this.taskListService = taskListService;
+        this._overrideSortState$ = new BehaviorSubject(null);
+        this._sortState$ = new BehaviorSubject({
+            [TaskListTab.ALL]: this._defaultSortState,
+            [TaskListTab.MINE]: this._defaultSortState,
+            [TaskListTab.OPEN]: this._defaultSortState,
+        });
+        this._sortStateForCurrentTaskType$ = combineLatest([
+            this.taskListService.selectedTaskType$,
+            this._sortState$,
+        ]).pipe(map(([selectedTaskType, sortStates]) => sortStates[selectedTaskType]));
+    }
+    updateSortState(taskType, updatedSortState) {
+        this._sortState$.pipe(take(1)).subscribe(sortState => {
+            this._sortState$.next({
+                ...sortState,
+                [taskType]: { ...sortState[taskType], ...updatedSortState },
+            });
+        });
+    }
+    updateSortStates(updatedSortState) {
+        this._sortState$.pipe(take(1)).subscribe(sortStates => {
+            const sortStatesCopy = { ...sortStates };
+            Object.keys(sortStates).forEach(taskType => {
+                sortStatesCopy[taskType] = { ...sortStatesCopy[taskType], ...updatedSortState };
+            });
+            this._sortState$.next(sortStatesCopy);
+        });
+    }
+    clearSortStates() {
+        this._sortState$.pipe(take(1)).subscribe(sortStates => {
+            const sortStatesCopy = { ...sortStates };
+            Object.keys(sortStates).forEach(taskType => {
+                sortStatesCopy[taskType] = null;
+            });
+            this._sortState$.next(sortStatesCopy);
+        });
+    }
+    resetDefaultSortStates() {
+        this._sortState$.pipe(take(1)).subscribe(sortStates => {
+            const sortStatesCopy = { ...sortStates };
+            Object.keys(sortStates).forEach(taskType => {
+                sortStatesCopy[taskType] = this._defaultSortState;
+            });
+            this._sortState$.next(sortStatesCopy);
+        });
+    }
+    getSortStateFromSortString(sortString) {
+        const splitString = sortString && sortString.split(',');
+        if (splitString?.length > 1) {
+            return {
+                isSorting: true,
+                state: {
+                    name: splitString[0],
+                    direction: splitString[1],
+                },
+            };
+        }
+        return null;
+    }
+    setOverrideSortState(state) {
+        this._overrideSortState$.next(state);
+    }
+    resetOverrideSortState() {
+        this._overrideSortState$.next(null);
+    }
+    getSortString(sort) {
+        return `${sort.state.name},${sort.state.direction}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListSortService, deps: [{ token: i1.TaskService }, { token: i2.TaskListService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListSortService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListSortService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.TaskService }, { type: i2.TaskListService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-list-sort.service.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/task/src/lib/services/task-list-sort.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2024 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (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 * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\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} from '@angular/core';\nimport {BehaviorSubject, combineLatest, Observable} from 'rxjs';\nimport {Direction, SortState, TaskListTab} from '@valtimo/config';\nimport {TaskService} from './task.service';\nimport {map, take} from 'rxjs/operators';\nimport {TaskListService} from './task-list.service';\n\n@Injectable()\nexport class TaskListSortService {\n  private readonly _overrideSortState$ = new BehaviorSubject<SortState | null>(null);\n\n  private readonly _sortState$ = new BehaviorSubject<{[key in TaskListTab]: SortState | null}>({\n    [TaskListTab.ALL]: this._defaultSortState,\n    [TaskListTab.MINE]: this._defaultSortState,\n    [TaskListTab.OPEN]: this._defaultSortState,\n  });\n\n  private readonly _sortStateForCurrentTaskType$: Observable<SortState> = combineLatest([\n    this.taskListService.selectedTaskType$,\n    this._sortState$,\n  ]).pipe(map(([selectedTaskType, sortStates]) => sortStates[selectedTaskType]));\n\n  public get sortStateForCurrentTaskType$(): Observable<SortState> {\n    return this._sortStateForCurrentTaskType$;\n  }\n\n  public get sortStringForCurrentTaskType$(): Observable<string | null> {\n    return this.sortStateForCurrentTaskType$.pipe(\n      map(sortState => (sortState ? this.getSortString(sortState) : null))\n    );\n  }\n\n  public get overrideSortState$(): Observable<SortState | null> {\n    return this._overrideSortState$.asObservable();\n  }\n\n  public get overrideSortStateString$(): Observable<string | null> {\n    return this._overrideSortState$.pipe(map(state => (state ? this.getSortString(state) : null)));\n  }\n\n  private get _defaultSortState(): SortState | null {\n    return this.taskService.getConfigCustomTaskList()?.defaultSortedColumn || null;\n  }\n\n  constructor(\n    private readonly taskService: TaskService,\n    private readonly taskListService: TaskListService\n  ) {}\n\n  public updateSortState(taskType: TaskListTab, updatedSortState: SortState): void {\n    this._sortState$.pipe(take(1)).subscribe(sortState => {\n      this._sortState$.next({\n        ...sortState,\n        [taskType]: {...sortState[taskType], ...updatedSortState},\n      });\n    });\n  }\n\n  public updateSortStates(updatedSortState: SortState): void {\n    this._sortState$.pipe(take(1)).subscribe(sortStates => {\n      const sortStatesCopy = {...sortStates};\n\n      Object.keys(sortStates).forEach(taskType => {\n        sortStatesCopy[taskType] = {...sortStatesCopy[taskType], ...updatedSortState};\n      });\n\n      this._sortState$.next(sortStatesCopy);\n    });\n  }\n\n  public clearSortStates(): void {\n    this._sortState$.pipe(take(1)).subscribe(sortStates => {\n      const sortStatesCopy = {...sortStates};\n\n      Object.keys(sortStates).forEach(taskType => {\n        sortStatesCopy[taskType] = null;\n      });\n\n      this._sortState$.next(sortStatesCopy);\n    });\n  }\n\n  public resetDefaultSortStates(): void {\n    this._sortState$.pipe(take(1)).subscribe(sortStates => {\n      const sortStatesCopy = {...sortStates};\n\n      Object.keys(sortStates).forEach(taskType => {\n        sortStatesCopy[taskType] = this._defaultSortState;\n      });\n\n      this._sortState$.next(sortStatesCopy);\n    });\n  }\n\n  public getSortStateFromSortString(sortString?: string): SortState | null {\n    const splitString = sortString && sortString.split(',');\n    if (splitString?.length > 1) {\n      return {\n        isSorting: true,\n        state: {\n          name: splitString[0],\n          direction: splitString[1] as Direction,\n        },\n      };\n    }\n\n    return null;\n  }\n\n  public setOverrideSortState(state: SortState): void {\n    this._overrideSortState$.next(state);\n  }\n\n  public resetOverrideSortState(): void {\n    this._overrideSortState$.next(null);\n  }\n\n  private getSortString(sort: SortState | null): string {\n    return `${sort.state.name},${sort.state.direction}`;\n  }\n}\n"]}

package/esm2022/lib/services/task-list.service.mjs

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2015-2024 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * 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 } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { TaskListTab } from '@valtimo/config';
+import * as i0 from "@angular/core";
+import * as i1 from "./task.service";
+export class TaskListService {
+    get caseDefinitionName$() {
+        return this._caseDefinitionName$.asObservable();
+    }
+    get selectedTaskType$() {
+        return this._selectedTaskType$.asObservable();
+    }
+    get selectedTaskType() {
+        return this._selectedTaskType$.getValue();
+    }
+    get loadingStateForCaseDefinition$() {
+        return this._loadingStateForCaseDefinition$.asObservable();
+    }
+    get ALL_CASES_ID() {
+        return this._ALL_CASES_ID;
+    }
+    constructor(taskService) {
+        this.taskService = taskService;
+        this._ALL_CASES_ID = 'ALL_CASES';
+        this._caseDefinitionName$ = new BehaviorSubject(null);
+        this._selectedTaskType$ = new BehaviorSubject(TaskListTab.MINE);
+        this._loadingStateForCaseDefinition$ = new BehaviorSubject(false);
+    }
+    setSelectedTaskType(type) {
+        this._selectedTaskType$.next(type);
+    }
+    setCaseDefinitionName(caseDefinitionName) {
+        this._loadingStateForCaseDefinition$.next(true);
+        this._caseDefinitionName$.next(caseDefinitionName);
+    }
+    setLoadingStateForCaseDefinition(loading) {
+        this._loadingStateForCaseDefinition$.next(loading);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListService, deps: [{ token: i1.TaskService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.TaskService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/services/task.service.mjs

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2015-2024 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * 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 } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { BaseApiService, TaskListTab, } from '@valtimo/config';
+import { InterceptorSkip } from '@valtimo/security';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@valtimo/config";
+export class TaskService extends BaseApiService {
+    constructor(httpClient, configService) {
+        super(httpClient, configService);
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    queryTasks(params) {
+        return this.httpClient.get(this.getApiUrl('/v1/task'), {
+            observe: 'response',
+            params,
+        });
+    }
+    queryTasksPage(params) {
+        return this.httpClient.get(this.getApiUrl('/v2/task'), {
+            params,
+        });
+    }
+    queryTasksPageV3(assigneeFilter = TaskListTab.ALL, pageParams, caseDefinitionName, otherFilters) {
+        let httpParams = new HttpParams().set('page', pageParams.page).set('size', pageParams.size);
+        if (pageParams.sort) {
+            httpParams = httpParams.append('sort', pageParams.sort);
+        }
+        if (caseDefinitionName && (otherFilters || []).length > 0) {
+            return this.searchTasks(httpParams, caseDefinitionName, otherFilters, assigneeFilter);
+        }
+        httpParams = httpParams.append('filter', assigneeFilter.toUpperCase());
+        return this.httpClient.post(this.getApiUrl('/v3/task'), { ...(caseDefinitionName && { caseDefinitionName }) }, { params: httpParams });
+    }
+    searchTasks(params, caseDefinitionName, otherFilters, assigneeFilter = TaskListTab.ALL) {
+        return this.httpClient.post(this.getApiUrl(`/v1/document-definition/${caseDefinitionName}/task/search`), {
+            caseDefinitionName,
+            assigneeFilter: assigneeFilter.toUpperCase(),
+            ...(otherFilters && { otherFilters }),
+        }, { params });
+    }
+    getTasks() {
+        return this.httpClient.get(this.getApiUrl('/v1/task?filter=all`'));
+    }
+    getTask(id) {
+        return this.httpClient.get(this.getApiUrl(`/v1/task/${id}`));
+    }
+    getCandidateUsers(id) {
+        return this.httpClient.get(this.getApiUrl(`/v2/task/${id}/candidate-user`));
+    }
+    assignTask(id, assigneeRequest) {
+        return this.httpClient.post(this.getApiUrl(`/v1/task/${id}/assign`), assigneeRequest);
+    }
+    unassignTask(id) {
+        return this.httpClient.post(this.getApiUrl(`/v1/task/${id}/unassign`), null);
+    }
+    completeTask(id, variables) {
+        return this.httpClient.post(this.getApiUrl(`/v1/task/${id}/complete`), {
+            variables,
+            filesToDelete: [],
+        });
+    }
+    getTaskProcessLink(taskId) {
+        return this.httpClient.get(this.getApiUrl(`/v2/process-link/task/${taskId}`), {
+            headers: { [InterceptorSkip]: '404' },
+        });
+    }
+    getTaskListColumns(caseDefinitionName) {
+        return this.httpClient.get(this.getApiUrl(`/v1/case/${caseDefinitionName}/task-list-column`));
+    }
+    getConfigCustomTaskList() {
+        return this.configService.config.customTaskList;
+    }
+    getTaskListSearchFields(caseDefinitionName) {
+        return this.httpClient.get(this.getApiUrl(`v1/search/field/TaskListSearchColumns/${caseDefinitionName}`));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskService, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.ConfigService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task.service.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/task/src/lib/services/task.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,EAAa,UAAU,EAAe,MAAM,sBAAsB,CAAC;AAY1E,OAAO,EACL,cAAc,EAKd,WAAW,GACZ,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;;;;AAGlD,MAAM,OAAO,WAAY,SAAQ,cAAc;IAC7C,YACqB,UAAsB,EACtB,aAA4B;QAE/C,KAAK,CAAC,UAAU,EAAE,aAAa,CAAC,CAAC;QAHd,eAAU,GAAV,UAAU,CAAY;QACtB,kBAAa,GAAb,aAAa,CAAe;IAGjD,CAAC;IAEM,UAAU,CAAC,MAAY;QAC5B,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAc,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE;YAClE,OAAO,EAAE,UAAU;YACnB,MAAM;SACP,CAAC,CAAC;IACL,CAAC;IAEM,cAAc,CAAC,MAAY;QAChC,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAa,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE;YACjE,MAAM;SACP,CAAC,CAAC;IACL,CAAC;IAEM,gBAAgB,CACrB,iBAA8B,WAAW,CAAC,GAAG,EAC7C,UAA0B,EAC1B,kBAA2B,EAC3B,YAAmC;QAEnC,IAAI,UAAU,GAAG,IAAI,UAAU,EAAE,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;QAE5F,IAAI,UAAU,CAAC,IAAI,EAAE,CAAC;YACpB,UAAU,GAAG,UAAU,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,IAAI,CAAC,CAAC;QAC1D,CAAC;QAED,IAAI,kBAAkB,IAAI,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1D,OAAO,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,kBAAkB,EAAE,YAAY,EAAE,cAAc,CAAC,CAAC;QACxF,CAAC;QAED,UAAU,GAAG,UAAU,CAAC,MAAM,CAAC,QAAQ,EAAE,cAAc,CAAC,WAAW,EAAE,CAAC,CAAC;QAEvE,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CACzB,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAC1B,EAAC,GAAG,CAAC,kBAAkB,IAAI,EAAC,kBAAkB,EAAC,CAAC,EAAC,EACjD,EAAC,MAAM,EAAE,UAAU,EAAC,CACrB,CAAC;IACJ,CAAC;IAEO,WAAW,CACjB,MAAkB,EAClB,kBAA0B,EAC1B,YAAkC,EAClC,iBAA8B,WAAW,CAAC,GAAG;QAE7C,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CACzB,IAAI,CAAC,SAAS,CAAC,2BAA2B,kBAAkB,cAAc,CAAC,EAC3E;YACE,kBAAkB;YAClB,cAAc,EAAE,cAAc,CAAC,WAAW,EAAE;YAC5C,GAAG,CAAC,YAAY,IAAI,EAAC,YAAY,EAAC,CAAC;SACpC,EACD,EAAC,MAAM,EAAC,CACT,CAAC;IACJ,CAAC;IAEM,QAAQ;QACb,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAS,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAAC,CAAC,CAAC;IAC7E,CAAC;IAEM,OAAO,CAAC,EAAU;QACvB,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC,CAAC;IAC/D,CAAC;IAEM,iBAAiB,CAAC,EAAU;QACjC,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAc,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAC3F,CAAC;IAEM,UAAU,CAAC,EAAU,EAAE,eAAgC;QAC5D,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,SAAS,CAAC,EAAE,eAAe,CAAC,CAAC;IACxF,CAAC;IAEM,YAAY,CAAC,EAAU;QAC5B,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,WAAW,CAAC,EAAE,IAAI,CAAC,CAAC;IAC/E,CAAC;IAEM,YAAY,CAAC,EAAU,EAAE,SAA2B;QACzD,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,EAAE,WAAW,CAAC,EAAE;YACrE,SAAS;YACT,aAAa,EAAE,EAAE;SAClB,CAAC,CAAC;IACL,CAAC;IAEM,kBAAkB,CAAC,MAAc;QACtC,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CACxB,IAAI,CAAC,SAAS,CAAC,yBAAyB,MAAM,EAAE,CAAC,EACjD;YACE,OAAO,EAAE,EAAC,CAAC,eAAe,CAAC,EAAE,KAAK,EAAC;SACpC,CACF,CAAC;IACJ,CAAC;IAEM,kBAAkB,CAAC,kBAA0B;QAClD,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CACxB,IAAI,CAAC,SAAS,CAAC,YAAY,kBAAkB,mBAAmB,CAAC,CAClE,CAAC;IACJ,CAAC;IAEM,uBAAuB;QAC5B,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,cAAc,CAAC;IAClD,CAAC;IAEM,uBAAuB,CAAC,kBAA0B;QACvD,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CACxB,IAAI,CAAC,SAAS,CAAC,yCAAyC,kBAAkB,EAAE,CAAC,CAC9E,CAAC;IACJ,CAAC;8GAjHU,WAAW;kHAAX,WAAW,cADC,MAAM;;2FAClB,WAAW;kBADvB,UAAU;mBAAC,EAAC,UAAU,EAAE,MAAM,EAAC","sourcesContent":["/*\n * Copyright 2015-2024 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (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 * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\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} from '@angular/core';\nimport {HttpClient, HttpParams, HttpResponse} from '@angular/common/http';\nimport {Observable} from 'rxjs';\nimport {\n  AssigneeRequest,\n  SpecifiedTask,\n  Task,\n  TaskListColumn,\n  TaskListOtherFilters,\n  TaskListSearchField,\n  TaskPageParams,\n  TaskProcessLinkResult,\n} from '../models';\nimport {\n  BaseApiService,\n  ConfigService,\n  CustomTaskList,\n  NamedUser,\n  Page,\n  TaskListTab,\n} from '@valtimo/config';\nimport {InterceptorSkip} from '@valtimo/security';\n\n@Injectable({providedIn: 'root'})\nexport class TaskService extends BaseApiService {\n  constructor(\n    protected readonly httpClient: HttpClient,\n    protected readonly configService: ConfigService\n  ) {\n    super(httpClient, configService);\n  }\n\n  public queryTasks(params?: any): Observable<HttpResponse<Array<Task>>> {\n    return this.httpClient.get<Array<Task>>(this.getApiUrl('/v1/task'), {\n      observe: 'response',\n      params,\n    });\n  }\n\n  public queryTasksPage(params?: any): Observable<Page<Task>> {\n    return this.httpClient.get<Page<Task>>(this.getApiUrl('/v2/task'), {\n      params,\n    });\n  }\n\n  public queryTasksPageV3(\n    assigneeFilter: TaskListTab = TaskListTab.ALL,\n    pageParams: TaskPageParams,\n    caseDefinitionName?: string,\n    otherFilters?: TaskListOtherFilters\n  ): Observable<Page<Task> | Page<SpecifiedTask>> {\n    let httpParams = new HttpParams().set('page', pageParams.page).set('size', pageParams.size);\n\n    if (pageParams.sort) {\n      httpParams = httpParams.append('sort', pageParams.sort);\n    }\n\n    if (caseDefinitionName && (otherFilters || []).length > 0) {\n      return this.searchTasks(httpParams, caseDefinitionName, otherFilters, assigneeFilter);\n    }\n\n    httpParams = httpParams.append('filter', assigneeFilter.toUpperCase());\n\n    return this.httpClient.post<Page<Task>>(\n      this.getApiUrl('/v3/task'),\n      {...(caseDefinitionName && {caseDefinitionName})},\n      {params: httpParams}\n    );\n  }\n\n  private searchTasks(\n    params: HttpParams,\n    caseDefinitionName: string,\n    otherFilters: TaskListOtherFilters,\n    assigneeFilter: TaskListTab = TaskListTab.ALL\n  ): Observable<Page<SpecifiedTask>> {\n    return this.httpClient.post<Page<SpecifiedTask>>(\n      this.getApiUrl(`/v1/document-definition/${caseDefinitionName}/task/search`),\n      {\n        caseDefinitionName,\n        assigneeFilter: assigneeFilter.toUpperCase(),\n        ...(otherFilters && {otherFilters}),\n      },\n      {params}\n    );\n  }\n\n  public getTasks(): Observable<Task[]> {\n    return this.httpClient.get<Task[]>(this.getApiUrl('/v1/task?filter=all`'));\n  }\n\n  public getTask(id: string): Observable<any> {\n    return this.httpClient.get(this.getApiUrl(`/v1/task/${id}`));\n  }\n\n  public getCandidateUsers(id: string): Observable<NamedUser[]> {\n    return this.httpClient.get<NamedUser[]>(this.getApiUrl(`/v2/task/${id}/candidate-user`));\n  }\n\n  public assignTask(id: string, assigneeRequest: AssigneeRequest): Observable<any> {\n    return this.httpClient.post(this.getApiUrl(`/v1/task/${id}/assign`), assigneeRequest);\n  }\n\n  public unassignTask(id: string): Observable<any> {\n    return this.httpClient.post(this.getApiUrl(`/v1/task/${id}/unassign`), null);\n  }\n\n  public completeTask(id: string, variables: Map<string, any>): Observable<any> {\n    return this.httpClient.post(this.getApiUrl(`/v1/task/${id}/complete`), {\n      variables,\n      filesToDelete: [],\n    });\n  }\n\n  public getTaskProcessLink(taskId: string): Observable<TaskProcessLinkResult> {\n    return this.httpClient.get<TaskProcessLinkResult>(\n      this.getApiUrl(`/v2/process-link/task/${taskId}`),\n      {\n        headers: {[InterceptorSkip]: '404'},\n      }\n    );\n  }\n\n  public getTaskListColumns(caseDefinitionName: string): Observable<TaskListColumn[]> {\n    return this.httpClient.get<TaskListColumn[]>(\n      this.getApiUrl(`/v1/case/${caseDefinitionName}/task-list-column`)\n    );\n  }\n\n  public getConfigCustomTaskList(): CustomTaskList {\n    return this.configService.config.customTaskList;\n  }\n\n  public getTaskListSearchFields(caseDefinitionName: string): Observable<TaskListSearchField[]> {\n    return this.httpClient.get<TaskListSearchField[]>(\n      this.getApiUrl(`v1/search/field/TaskListSearchColumns/${caseDefinitionName}`)\n    );\n  }\n}\n"]}

package/esm2022/lib/task-permissions.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2023 Ritense BV, the Netherlands.
+ * Copyright 2015-2024 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -36,4 +36,4 @@ const CAN_VIEW_CASE_PERMISSION = {
     resource: TASK_DETAIL_PERMISSION_RESOURCE.jsonSchemaDocument,
 };
 export { CAN_ASSIGN_TASK_PERMISSION, CAN_VIEW_TASK_PERMISSION, CAN_VIEW_CASE_PERMISSION, TASK_DETAIL_PERMISSION_RESOURCE, };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/task-routing.module.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2023 Ritense BV, the Netherlands.
+ * Copyright 2015-2024 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,7 +17,7 @@ import { NgModule } from '@angular/core';
 import { RouterModule } from '@angular/router';
 import { CommonModule } from '@angular/common';
 import { AuthGuardService } from '@valtimo/security';
-import { TaskListComponent } from './task-list/task-list.component';
+import { TaskListComponent } from './components/task-list/task-list.component';
 import { ROLE_USER } from '@valtimo/config';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/router";
@@ -30,11 +30,11 @@ const routes = [
     },
 ];
 export class TaskRoutingModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TaskRoutingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: TaskRoutingModule, imports: [CommonModule, i1.RouterModule], exports: [RouterModule] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TaskRoutingModule, imports: [CommonModule, RouterModule.forChild(routes), RouterModule] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskRoutingModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.3", ngImport: i0, type: TaskRoutingModule, imports: [CommonModule, i1.RouterModule], exports: [RouterModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskRoutingModule, imports: [CommonModule, RouterModule.forChild(routes), RouterModule] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: TaskRoutingModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskRoutingModule, decorators: [{
             type: NgModule,
             args: [{
                     declarations: [],
@@ -42,4 +42,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                     exports: [RouterModule],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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