@valtimo/task 11.3.2 → 12.0.1

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

@@ -0,0 +1,192 @@
+/*
+ * 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 { ViewType } from '@valtimo/components';
+import { BehaviorSubject, filter, switchMap, tap } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./task.service";
+import * as i2 from "./task-list.service";
+import * as i3 from "./task-list-sort.service";
+export class TaskListColumnService {
+    get hasCustomConfigTaskList() {
+        return !!this.taskService.getConfigCustomTaskList();
+    }
+    get fields$() {
+        return this._fields$.asObservable();
+    }
+    get taskListColumnsForCase$() {
+        return this.taskListService.caseDefinitionName$.pipe(tap(caseDefinitionName => {
+            if (caseDefinitionName === this.taskListService.ALL_CASES_ID) {
+                this.resetTaskListFields();
+            }
+        }), filter(caseDefinitionName => !!caseDefinitionName && caseDefinitionName !== this.taskListService.ALL_CASES_ID), switchMap(caseDefinitionName => this.taskService.getTaskListColumns(caseDefinitionName)), tap(taskListColumns => {
+            if (taskListColumns.length === 0) {
+                this.taskListSortService.updateSortStates({
+                    isSorting: true,
+                    state: {
+                        name: this._DEFAULT_SPECIFIED_TASK_LIST_FIELDS[0].key,
+                        direction: 'DESC',
+                    },
+                });
+                this._fields$.next(this._DEFAULT_SPECIFIED_TASK_LIST_FIELDS);
+            }
+            else {
+                this._fields$.next(this.mapTaskListColumnToColumnConfig(taskListColumns));
+            }
+        }), tap(() => this.taskListService.setLoadingStateForCaseDefinition(false)));
+    }
+    constructor(taskService, taskListService, taskListSortService) {
+        this.taskService = taskService;
+        this.taskListService = taskListService;
+        this.taskListSortService = taskListSortService;
+        this._DEFAULT_TASK_LIST_FIELDS = [
+            {
+                key: 'created',
+                label: `task-list.fieldLabels.created`,
+                viewType: ViewType.TEXT,
+                sortable: true,
+            },
+            {
+                key: 'name',
+                label: `task-list.fieldLabels.name`,
+                viewType: ViewType.TEXT,
+                sortable: true,
+            },
+            {
+                key: 'valtimoAssignee.fullName',
+                label: `task-list.fieldLabels.valtimoAssignee.fullName`,
+                viewType: ViewType.TEXT,
+            },
+            {
+                key: 'due',
+                label: `task-list.fieldLabels.due`,
+                viewType: ViewType.TEXT,
+                sortable: true,
+            },
+            {
+                key: 'context',
+                label: `task-list.fieldLabels.context`,
+                viewType: ViewType.TEXT,
+            },
+        ];
+        this._DEFAULT_SPECIFIED_TASK_LIST_FIELDS = [
+            {
+                key: 'createTime',
+                label: `task-list.fieldLabels.created`,
+                viewType: ViewType.TEXT,
+                sortable: true,
+            },
+            {
+                key: 'name',
+                label: `task-list.fieldLabels.name`,
+                viewType: ViewType.TEXT,
+                sortable: true,
+            },
+            {
+                key: 'assignee',
+                label: `task-list.fieldLabels.valtimoAssignee.fullName`,
+                viewType: ViewType.TEXT,
+            },
+            {
+                key: 'dueDate',
+                label: `task-list.fieldLabels.due`,
+                viewType: ViewType.TEXT,
+                sortable: true,
+            },
+        ];
+        this._fields$ = new BehaviorSubject(this._DEFAULT_TASK_LIST_FIELDS);
+    }
+    resetTaskListFields() {
+        if (this.hasCustomConfigTaskList) {
+            this.setFieldsToCustomTaskListFields();
+        }
+        else {
+            this.setFieldsToDefaultTaskListFields();
+        }
+        this.taskListSortService.resetDefaultSortStates();
+        this.taskListService.setLoadingStateForCaseDefinition(false);
+    }
+    setFieldsToCustomTaskListFields() {
+        const customTaskListFields = this.taskService.getConfigCustomTaskList().fields;
+        if (customTaskListFields) {
+            this._fields$.next(customTaskListFields.map((column, index) => ({
+                key: column.propertyName,
+                label: `task-list.fieldLabels.${column.translationKey}`,
+                sortable: column.sortable,
+                ...(column.viewType && { viewType: column.viewType }),
+                ...(column.enum && { enum: column.enum }),
+            })));
+        }
+    }
+    setFieldsToDefaultTaskListFields() {
+        this._fields$.next(this._DEFAULT_TASK_LIST_FIELDS);
+    }
+    mapTaskListColumnToColumnConfig(taskListColumns) {
+        const hasDefaultSort = !!taskListColumns.find(column => column.defaultSort);
+        const firstSortableColumn = taskListColumns.find(column => column.sortable);
+        if (!hasDefaultSort && firstSortableColumn) {
+            this.taskListSortService.updateSortStates({
+                isSorting: true,
+                state: {
+                    name: firstSortableColumn.key,
+                    direction: 'DESC',
+                },
+            });
+        }
+        if (!hasDefaultSort && !firstSortableColumn) {
+            this.taskListSortService.clearSortStates();
+        }
+        return taskListColumns.map(column => {
+            if (column.defaultSort) {
+                this.taskListSortService.updateSortStates({
+                    isSorting: true,
+                    state: {
+                        name: column.key,
+                        direction: column.defaultSort,
+                    },
+                });
+            }
+            return {
+                viewType: this.getViewType(column.displayType.type),
+                key: column.key,
+                label: column.title || column.key,
+                sortable: column.sortable,
+                ...(column?.displayType?.displayTypeParameters?.enum && {
+                    enum: column?.displayType?.displayTypeParameters?.enum,
+                }),
+                ...(column?.displayType?.displayTypeParameters?.dateFormat && {
+                    format: column?.displayType?.displayTypeParameters?.dateFormat,
+                }),
+            };
+        });
+    }
+    getViewType(taskListColumnColumnDisplayType) {
+        switch (taskListColumnColumnDisplayType) {
+            case 'arrayCount':
+                return 'relatedFiles';
+            case 'underscoresToSpaces':
+                return 'stringReplaceUnderscore';
+            default:
+                return taskListColumnColumnDisplayType;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListColumnService, deps: [{ token: i1.TaskService }, { token: i2.TaskListService }, { token: i3.TaskListSortService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListColumnService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListColumnService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.TaskService }, { type: i2.TaskListService }, { type: i3.TaskListSortService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-list-column.service.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/task/src/lib/services/task-list-column.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 {ColumnConfig, ViewType} from '@valtimo/components';\nimport {BehaviorSubject, filter, Observable, switchMap, tap} from 'rxjs';\nimport {TaskService} from './task.service';\nimport {TaskListColumn} from '../models';\nimport {TaskListService} from './task-list.service';\nimport {TaskListSortService} from './task-list-sort.service';\n\n@Injectable()\nexport class TaskListColumnService {\n  private readonly _DEFAULT_TASK_LIST_FIELDS: ColumnConfig[] = [\n    {\n      key: 'created',\n      label: `task-list.fieldLabels.created`,\n      viewType: ViewType.TEXT,\n      sortable: true,\n    },\n    {\n      key: 'name',\n      label: `task-list.fieldLabels.name`,\n      viewType: ViewType.TEXT,\n      sortable: true,\n    },\n    {\n      key: 'valtimoAssignee.fullName',\n      label: `task-list.fieldLabels.valtimoAssignee.fullName`,\n      viewType: ViewType.TEXT,\n    },\n    {\n      key: 'due',\n      label: `task-list.fieldLabels.due`,\n      viewType: ViewType.TEXT,\n      sortable: true,\n    },\n    {\n      key: 'context',\n      label: `task-list.fieldLabels.context`,\n      viewType: ViewType.TEXT,\n    },\n  ];\n\n  private readonly _DEFAULT_SPECIFIED_TASK_LIST_FIELDS: ColumnConfig[] = [\n    {\n      key: 'createTime',\n      label: `task-list.fieldLabels.created`,\n      viewType: ViewType.TEXT,\n      sortable: true,\n    },\n    {\n      key: 'name',\n      label: `task-list.fieldLabels.name`,\n      viewType: ViewType.TEXT,\n      sortable: true,\n    },\n    {\n      key: 'assignee',\n      label: `task-list.fieldLabels.valtimoAssignee.fullName`,\n      viewType: ViewType.TEXT,\n    },\n    {\n      key: 'dueDate',\n      label: `task-list.fieldLabels.due`,\n      viewType: ViewType.TEXT,\n      sortable: true,\n    },\n  ];\n\n  private readonly _fields$ = new BehaviorSubject<ColumnConfig[]>(this._DEFAULT_TASK_LIST_FIELDS);\n\n  private get hasCustomConfigTaskList(): boolean {\n    return !!this.taskService.getConfigCustomTaskList();\n  }\n\n  public get fields$(): Observable<ColumnConfig[]> {\n    return this._fields$.asObservable();\n  }\n\n  public get taskListColumnsForCase$(): Observable<TaskListColumn[]> {\n    return this.taskListService.caseDefinitionName$.pipe(\n      tap(caseDefinitionName => {\n        if (caseDefinitionName === this.taskListService.ALL_CASES_ID) {\n          this.resetTaskListFields();\n        }\n      }),\n      filter(\n        caseDefinitionName =>\n          !!caseDefinitionName && caseDefinitionName !== this.taskListService.ALL_CASES_ID\n      ),\n      switchMap(caseDefinitionName => this.taskService.getTaskListColumns(caseDefinitionName)),\n      tap(taskListColumns => {\n        if (taskListColumns.length === 0) {\n          this.taskListSortService.updateSortStates({\n            isSorting: true,\n            state: {\n              name: this._DEFAULT_SPECIFIED_TASK_LIST_FIELDS[0].key,\n              direction: 'DESC',\n            },\n          });\n          this._fields$.next(this._DEFAULT_SPECIFIED_TASK_LIST_FIELDS);\n        } else {\n          this._fields$.next(this.mapTaskListColumnToColumnConfig(taskListColumns));\n        }\n      }),\n      tap(() => this.taskListService.setLoadingStateForCaseDefinition(false))\n    );\n  }\n\n  constructor(\n    private readonly taskService: TaskService,\n    private readonly taskListService: TaskListService,\n    private readonly taskListSortService: TaskListSortService\n  ) {}\n\n  public resetTaskListFields(): void {\n    if (this.hasCustomConfigTaskList) {\n      this.setFieldsToCustomTaskListFields();\n    } else {\n      this.setFieldsToDefaultTaskListFields();\n    }\n\n    this.taskListSortService.resetDefaultSortStates();\n    this.taskListService.setLoadingStateForCaseDefinition(false);\n  }\n\n  private setFieldsToCustomTaskListFields(): void {\n    const customTaskListFields = this.taskService.getConfigCustomTaskList().fields;\n\n    if (customTaskListFields) {\n      this._fields$.next(\n        customTaskListFields.map((column, index) => ({\n          key: column.propertyName,\n          label: `task-list.fieldLabels.${column.translationKey}`,\n          sortable: column.sortable,\n          ...(column.viewType && {viewType: column.viewType}),\n          ...(column.enum && {enum: column.enum}),\n        }))\n      );\n    }\n  }\n\n  private setFieldsToDefaultTaskListFields(): void {\n    this._fields$.next(this._DEFAULT_TASK_LIST_FIELDS);\n  }\n\n  private mapTaskListColumnToColumnConfig(\n    taskListColumns: Array<TaskListColumn>\n  ): Array<ColumnConfig> {\n    const hasDefaultSort = !!taskListColumns.find(column => column.defaultSort);\n    const firstSortableColumn = taskListColumns.find(column => column.sortable);\n\n    if (!hasDefaultSort && firstSortableColumn) {\n      this.taskListSortService.updateSortStates({\n        isSorting: true,\n        state: {\n          name: firstSortableColumn.key,\n          direction: 'DESC',\n        },\n      });\n    }\n\n    if (!hasDefaultSort && !firstSortableColumn) {\n      this.taskListSortService.clearSortStates();\n    }\n\n    return taskListColumns.map(column => {\n      if (column.defaultSort) {\n        this.taskListSortService.updateSortStates({\n          isSorting: true,\n          state: {\n            name: column.key,\n            direction: column.defaultSort,\n          },\n        });\n      }\n\n      return {\n        viewType: this.getViewType(column.displayType.type),\n        key: column.key,\n        label: column.title || column.key,\n        sortable: column.sortable,\n        ...(column?.displayType?.displayTypeParameters?.enum && {\n          enum: column?.displayType?.displayTypeParameters?.enum,\n        }),\n        ...(column?.displayType?.displayTypeParameters?.dateFormat && {\n          format: column?.displayType?.displayTypeParameters?.dateFormat,\n        }),\n      };\n    });\n  }\n\n  private getViewType(taskListColumnColumnDisplayType: string): string {\n    switch (taskListColumnColumnDisplayType) {\n      case 'arrayCount':\n        return 'relatedFiles';\n      case 'underscoresToSpaces':\n        return 'stringReplaceUnderscore';\n      default:\n        return taskListColumnColumnDisplayType;\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,74 @@
+/*
+ * 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-list.service";
+export class TaskListPaginationService {
+    get paginationForCurrentTaskType$() {
+        return this._paginationForCurrentTaskType$;
+    }
+    get paginationForCurrentTaskTypeForList$() {
+        return this._paginationForCurrentTaskType$.pipe(map(pagination => ({ ...pagination, page: pagination?.page + 1 || 1 })));
+    }
+    constructor(taskListService) {
+        this.taskListService = taskListService;
+        this._pagination$ = new BehaviorSubject({
+            [TaskListTab.ALL]: this.getDefaultPagination(),
+            [TaskListTab.MINE]: this.getDefaultPagination(),
+            [TaskListTab.OPEN]: this.getDefaultPagination(),
+        });
+        this._paginationForCurrentTaskType$ = combineLatest([
+            this.taskListService.selectedTaskType$,
+            this._pagination$,
+        ]).pipe(map(([selectedTaskType, pagination]) => pagination[selectedTaskType]));
+    }
+    updateTaskPagination(taskType, updatedPagination) {
+        this._pagination$.pipe(take(1)).subscribe(pagination => {
+            const currentPagination = pagination[taskType];
+            this._pagination$.next({
+                ...pagination,
+                [taskType]: { ...currentPagination, ...updatedPagination },
+            });
+        });
+    }
+    getLastAvailablePage(page, size, collectionSize) {
+        if (this.isNumber(page) && this.isNumber(size) && this.isNumber(collectionSize) && page !== 0) {
+            const amountOfPages = Math.ceil(collectionSize / size);
+            if (page + 1 > amountOfPages) {
+                return amountOfPages - 1;
+            }
+        }
+        return page;
+    }
+    isNumber(value) {
+        return typeof value === 'number';
+    }
+    getDefaultPagination() {
+        return {
+            page: 0,
+            size: 10,
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListPaginationService, deps: [{ token: i1.TaskListService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListPaginationService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: TaskListPaginationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.TaskListService }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,90 @@
+/*
+ * 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 _defaultSortState() {
+        return this.taskService.getConfigCustomTaskList()?.defaultSortedColumn || null;
+    }
+    constructor(taskService, taskListService) {
+        this.taskService = taskService;
+        this.taskListService = taskListService;
+        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);
+        });
+    }
+    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 {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 _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  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  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,94 @@
+/*
+ * 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) {
+        let httpParams = new HttpParams()
+            .set('filter', assigneeFilter.toUpperCase())
+            .set('page', pageParams.page)
+            .set('size', pageParams.size);
+        if (pageParams.sort) {
+            httpParams = httpParams.append('sort', pageParams.sort);
+        }
+        if (caseDefinitionName) {
+            return this.httpClient.post(this.getApiUrl('/v3/task'), {
+                caseDefinitionName,
+            }, { params: httpParams });
+        }
+        return this.httpClient.post(this.getApiUrl('/v3/task'), {}, { params: httpParams });
+    }
+    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;
+    }
+    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":"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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 {HttpClient, HttpParams, HttpResponse} from '@angular/common/http';\nimport {Observable} from 'rxjs';\nimport {\n  AssigneeRequest,\n  SpecifiedTask,\n  Task,\n  TaskListColumn,\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  ): Observable<Page<Task> | Page<SpecifiedTask>> {\n    let httpParams = new HttpParams()\n      .set('filter', assigneeFilter.toUpperCase())\n      .set('page', pageParams.page)\n      .set('size', pageParams.size);\n\n    if (pageParams.sort) {\n      httpParams = httpParams.append('sort', pageParams.sort);\n    }\n\n    if (caseDefinitionName) {\n      return this.httpClient.post<Page<SpecifiedTask>>(\n        this.getApiUrl('/v3/task'),\n        {\n          caseDefinitionName,\n        },\n        {params: httpParams}\n      );\n    }\n\n    return this.httpClient.post<Page<Task>>(this.getApiUrl('/v3/task'), {}, {params: httpParams});\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"]}

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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