TSK-1642: now setting details attribute for TaskTransferHistoryEvent
This commit is contained in:
Mustapha Zorgati
parent
c9f7f871df
commit
b66e4d9f86
|
|
@ -57,7 +57,7 @@ public class ObjectAttributeChangeDetector {
|
|||
.peek(field -> field.setAccessible(true))
|
||||
.map(
|
||||
CheckedFunction.wrap(
|
||||
field -> new Triplet<>(field, field.get(oldObject), field.get(newObject))))
|
||||
field -> Triplet.of(field, field.get(oldObject), field.get(newObject))))
|
||||
.filter(areFieldsNotEqual.and(isFieldNotCustomAttributes))
|
||||
.map(
|
||||
fieldAndValuePairTriplet -> {
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ public final class Pair<L, R> {
|
|||
|
||||
private final R right;
|
||||
|
||||
public Pair(L left, R right) {
|
||||
private Pair(L left, R right) {
|
||||
this.left = left;
|
||||
this.right = right;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -6,12 +6,16 @@ public class Triplet<L, M, R> {
|
|||
private final M middle;
|
||||
private final R right;
|
||||
|
||||
public Triplet(L left, M middle, R right) {
|
||||
private Triplet(L left, M middle, R right) {
|
||||
this.left = left;
|
||||
this.middle = middle;
|
||||
this.right = right;
|
||||
}
|
||||
|
||||
public static <L, M, R> Triplet<L, M, R> of(L left, M middle, R right) {
|
||||
return new Triplet<>(left, middle, right);
|
||||
}
|
||||
|
||||
public L getLeft() {
|
||||
return left;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,13 +1,20 @@
|
|||
package acceptance.events.task;
|
||||
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static pro.taskana.common.internal.util.CheckedConsumer.wrap;
|
||||
|
||||
import acceptance.AbstractAccTest;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import java.util.function.Consumer;
|
||||
import java.util.stream.Stream;
|
||||
import org.json.JSONArray;
|
||||
import org.json.JSONObject;
|
||||
import org.junit.jupiter.api.DynamicTest;
|
||||
import org.junit.jupiter.api.TestFactory;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
import org.junit.jupiter.api.function.ThrowingConsumer;
|
||||
|
||||
import pro.taskana.common.internal.util.Triplet;
|
||||
import pro.taskana.common.test.security.JaasExtension;
|
||||
import pro.taskana.common.test.security.WithAccessId;
|
||||
import pro.taskana.simplehistory.impl.SimpleHistoryServiceImpl;
|
||||
|
|
@ -16,6 +23,8 @@ import pro.taskana.simplehistory.impl.task.TaskHistoryQueryMapper;
|
|||
import pro.taskana.spi.history.api.events.task.TaskHistoryEvent;
|
||||
import pro.taskana.spi.history.api.events.task.TaskHistoryEventType;
|
||||
import pro.taskana.task.api.TaskService;
|
||||
import pro.taskana.workbasket.api.WorkbasketService;
|
||||
import pro.taskana.workbasket.api.models.Workbasket;
|
||||
|
||||
@ExtendWith(JaasExtension.class)
|
||||
class CreateHistoryEventOnTaskTransferAccTest extends AbstractAccTest {
|
||||
|
|
@ -24,10 +33,25 @@ class CreateHistoryEventOnTaskTransferAccTest extends AbstractAccTest {
|
|||
private final SimpleHistoryServiceImpl historyService = getHistoryService();
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void should_CreateTransferredHistoryEvent_When_TaskIstransferred() throws Exception {
|
||||
@TestFactory
|
||||
Stream<DynamicTest> should_CreateTransferredHistoryEvent_When_TaskIsTransferred() {
|
||||
List<Triplet<String, String, Consumer<String>>> testCases =
|
||||
List.of(
|
||||
Triplet.of(
|
||||
"Using WorkbasketId",
|
||||
"TKI:000000000000000000000000000000000003",
|
||||
wrap(
|
||||
(String taskId) ->
|
||||
taskService.transfer(taskId, "WBI:100000000000000000000000000000000006"))),
|
||||
Triplet.of(
|
||||
"Using WorkbasketKey and Domain",
|
||||
"TKI:000000000000000000000000000000000004",
|
||||
wrap((String taskId) -> taskService.transfer(taskId, "USER-1-1", "DOMAIN_A"))));
|
||||
|
||||
final String taskId = "TKI:000000000000000000000000000000000003";
|
||||
ThrowingConsumer<Triplet<String, String, Consumer<String>>> test =
|
||||
t -> {
|
||||
String taskId = t.getMiddle();
|
||||
Consumer<String> transferMethod = t.getRight();
|
||||
|
||||
TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper();
|
||||
|
||||
|
|
@ -37,63 +61,112 @@ class CreateHistoryEventOnTaskTransferAccTest extends AbstractAccTest {
|
|||
|
||||
assertThat(events).isEmpty();
|
||||
|
||||
taskService.transfer(taskId, "WBI:100000000000000000000000000000000006");
|
||||
transferMethod.accept(taskId);
|
||||
|
||||
events =
|
||||
taskHistoryQueryMapper.queryHistoryEvents(
|
||||
(TaskHistoryQueryImpl) historyService.createTaskHistoryQuery().taskIdIn(taskId));
|
||||
|
||||
assertThat(events).hasSize(1);
|
||||
assertTransferHistoryEvent(
|
||||
events.get(0).getId(),
|
||||
"WBI:100000000000000000000000000000000001",
|
||||
"WBI:100000000000000000000000000000000006",
|
||||
"admin");
|
||||
};
|
||||
|
||||
String eventType = events.get(0).getEventType();
|
||||
|
||||
assertThat(eventType).isEqualTo(TaskHistoryEventType.TRANSFERRED.getName());
|
||||
return DynamicTest.stream(testCases.iterator(), Triplet::getLeft, test);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void should_CreateTransferredHistoryEvents_When_TaskBulkTransfer() throws Exception {
|
||||
@TestFactory
|
||||
Stream<DynamicTest> should_CreateTransferredHistoryEvents_When_TaskBulkTransfer() {
|
||||
List<Triplet<String, List<String>, Consumer<List<String>>>> testCases =
|
||||
List.of(
|
||||
Triplet.of(
|
||||
"Using WorkbasketId",
|
||||
List.of(
|
||||
"TKI:000000000000000000000000000000000021",
|
||||
"TKI:000000000000000000000000000000000022"),
|
||||
wrap(
|
||||
(List<String> taskIds) ->
|
||||
taskService.transferTasks(
|
||||
"WBI:100000000000000000000000000000000007", taskIds))),
|
||||
Triplet.of(
|
||||
"Using WorkbasketKey and Domain",
|
||||
List.of(
|
||||
"TKI:000000000000000000000000000000000023",
|
||||
"TKI:000000000000000000000000000000000024"),
|
||||
wrap(
|
||||
(List<String> taskIds) ->
|
||||
taskService.transferTasks("USER-1-2", "DOMAIN_A", taskIds))));
|
||||
|
||||
final String taskId = "TKI:000000000000000000000000000000000004";
|
||||
final String taskId2 = "TKI:000000000000000000000000000000000002";
|
||||
|
||||
final String destinationWorkbasketKey = "WBI:100000000000000000000000000000000007";
|
||||
|
||||
List<String> taskIds = new ArrayList<>();
|
||||
|
||||
taskIds.add(taskId);
|
||||
taskIds.add(taskId2);
|
||||
ThrowingConsumer<Triplet<String, List<String>, Consumer<List<String>>>> test =
|
||||
t -> {
|
||||
List<String> taskIds = t.getMiddle();
|
||||
Consumer<List<String>> transferMethod = t.getRight();
|
||||
|
||||
TaskHistoryQueryMapper taskHistoryQueryMapper = getHistoryQueryMapper();
|
||||
|
||||
List<TaskHistoryEvent> events =
|
||||
taskHistoryQueryMapper.queryHistoryEvents(
|
||||
(TaskHistoryQueryImpl)
|
||||
historyService.createTaskHistoryQuery().taskIdIn(taskIds.toArray(new String[0])));
|
||||
historyService
|
||||
.createTaskHistoryQuery()
|
||||
.taskIdIn(taskIds.toArray(new String[0])));
|
||||
|
||||
assertThat(events).isEmpty();
|
||||
|
||||
taskService.transferTasks(destinationWorkbasketKey, taskIds);
|
||||
transferMethod.accept(taskIds);
|
||||
|
||||
events =
|
||||
taskHistoryQueryMapper.queryHistoryEvents(
|
||||
(TaskHistoryQueryImpl)
|
||||
historyService
|
||||
.createTaskHistoryQuery()
|
||||
.taskIdIn(taskIds.stream().toArray(String[]::new)));
|
||||
|
||||
assertThat(events).hasSize(2);
|
||||
.taskIdIn(taskIds.toArray(new String[0])));
|
||||
|
||||
assertThat(events)
|
||||
.extracting(TaskHistoryEvent::getEventType)
|
||||
.containsOnly(TaskHistoryEventType.TRANSFERRED.getName());
|
||||
.extracting(TaskHistoryEvent::getTaskId)
|
||||
.containsExactlyInAnyOrderElementsOf(taskIds);
|
||||
|
||||
assertThat(events)
|
||||
.extracting(TaskHistoryEvent::getOldValue)
|
||||
.containsExactlyInAnyOrder(
|
||||
"WBI:100000000000000000000000000000000006", "WBI:100000000000000000000000000000000001");
|
||||
for (TaskHistoryEvent event : events) {
|
||||
assertTransferHistoryEvent(
|
||||
event.getId(),
|
||||
"WBI:100000000000000000000000000000000001",
|
||||
"WBI:100000000000000000000000000000000007",
|
||||
"admin");
|
||||
}
|
||||
};
|
||||
|
||||
assertThat(events)
|
||||
.extracting(TaskHistoryEvent::getNewValue)
|
||||
.containsOnly("WBI:100000000000000000000000000000000007");
|
||||
return DynamicTest.stream(testCases.iterator(), Triplet::getLeft, test);
|
||||
}
|
||||
|
||||
private void assertTransferHistoryEvent(
|
||||
String eventId, String expectedOldValue, String expectedNewValue, String expectedUser)
|
||||
throws Exception {
|
||||
TaskHistoryEvent event = historyService.getTaskHistoryEvent(eventId);
|
||||
assertThat(event.getDetails()).isNotNull();
|
||||
JSONArray changes = new JSONObject(event.getDetails()).getJSONArray("changes");
|
||||
|
||||
assertThat(changes.length()).isPositive();
|
||||
for (int i = 0; i < changes.length(); i++) {
|
||||
JSONObject change = changes.getJSONObject(i);
|
||||
if (change.get("fieldName").equals("workbasketSummary")) {
|
||||
String oldWorkbasketStr = (String) change.get("oldValue");
|
||||
String newWorkbasketStr = (String) change.get("newValue");
|
||||
WorkbasketService workbasketService = taskanaEngine.getWorkbasketService();
|
||||
Workbasket oldWorkbasket = workbasketService.getWorkbasket(expectedOldValue);
|
||||
assertThat(oldWorkbasket.asSummary()).hasToString(oldWorkbasketStr);
|
||||
Workbasket newWorkbasket = workbasketService.getWorkbasket(expectedNewValue);
|
||||
assertThat(newWorkbasket.asSummary()).hasToString(newWorkbasketStr);
|
||||
}
|
||||
}
|
||||
|
||||
assertThat(event.getId()).startsWith("THI:");
|
||||
assertThat(event.getOldValue()).isEqualTo(expectedOldValue);
|
||||
assertThat(event.getNewValue()).isEqualTo(expectedNewValue);
|
||||
assertThat(event.getUserId()).isEqualTo(expectedUser);
|
||||
assertThat(event.getEventType()).isEqualTo(TaskHistoryEventType.TRANSFERRED.getName());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,13 +1,18 @@
|
|||
package pro.taskana.spi.history.api.events.task;
|
||||
|
||||
import pro.taskana.task.api.models.Task;
|
||||
import pro.taskana.task.api.models.TaskSummary;
|
||||
|
||||
/** Event fired if a task is transferred. */
|
||||
public class TaskTransferredEvent extends TaskHistoryEvent {
|
||||
|
||||
public TaskTransferredEvent(
|
||||
String id, Task task, String oldWorkbasketId, String newWorkbasketId, String userId) {
|
||||
super(id, task, userId, null);
|
||||
String id,
|
||||
TaskSummary task,
|
||||
String oldWorkbasketId,
|
||||
String newWorkbasketId,
|
||||
String userId,
|
||||
String details) {
|
||||
super(id, task, userId, details);
|
||||
eventType = TaskHistoryEventType.TRANSFERRED.getName();
|
||||
created = task.getModified();
|
||||
this.oldValue = oldWorkbasketId;
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@ package pro.taskana.task.internal;
|
|||
import java.time.Instant;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import org.apache.ibatis.annotations.Delete;
|
||||
import org.apache.ibatis.annotations.Insert;
|
||||
import org.apache.ibatis.annotations.Options;
|
||||
|
|
@ -18,7 +19,6 @@ import pro.taskana.task.api.CallbackState;
|
|||
import pro.taskana.task.api.models.TaskSummary;
|
||||
import pro.taskana.task.internal.models.MinimalTaskSummary;
|
||||
import pro.taskana.task.internal.models.TaskImpl;
|
||||
import pro.taskana.task.internal.models.TaskSummaryImpl;
|
||||
|
||||
/** This class is the mybatis mapping of task. */
|
||||
@SuppressWarnings("checkstyle:LineLength")
|
||||
|
|
@ -146,8 +146,7 @@ public interface TaskMapper {
|
|||
+ " WHERE ID IN <foreach item='taskId' index='index' separator=',' open='(' close=')' collection='taskIds'>#{taskId}</foreach>"
|
||||
+ "</script>")
|
||||
void updateTransfered(
|
||||
@Param("taskIds") List<String> taskIds,
|
||||
@Param("referencetask") TaskSummaryImpl referencetask);
|
||||
@Param("taskIds") Set<String> taskIds, @Param("referencetask") TaskImpl referencetask);
|
||||
|
||||
@Update(
|
||||
"<script>"
|
||||
|
|
|
|||
|
|
@ -884,7 +884,7 @@ public class TaskServiceImpl implements TaskService {
|
|||
Pair<List<MinimalTaskSummary>, BulkLog> filteredPair =
|
||||
filterTasksAuthorizedForAndLogErrorsForNotAuthorized(minimalTaskSummaries);
|
||||
bulkLog.addAllErrors(filteredPair.getRight());
|
||||
return new Pair<>(filteredPair.getLeft(), bulkLog);
|
||||
return Pair.of(filteredPair.getLeft(), bulkLog);
|
||||
}
|
||||
|
||||
Pair<List<MinimalTaskSummary>, BulkLog> filterTasksAuthorizedForAndLogErrorsForNotAuthorized(
|
||||
|
|
@ -892,7 +892,7 @@ public class TaskServiceImpl implements TaskService {
|
|||
BulkLog bulkLog = new BulkLog();
|
||||
// check authorization only for non-admin or task-admin users
|
||||
if (taskanaEngine.getEngine().isUserInRole(TaskanaRole.ADMIN, TaskanaRole.TASK_ADMIN)) {
|
||||
return new Pair<>(existingTasks, bulkLog);
|
||||
return Pair.of(existingTasks, bulkLog);
|
||||
} else {
|
||||
List<String> taskIds =
|
||||
existingTasks.stream().map(MinimalTaskSummary::getTaskId).collect(Collectors.toList());
|
||||
|
|
@ -911,7 +911,7 @@ public class TaskServiceImpl implements TaskService {
|
|||
existingTasks.stream()
|
||||
.filter(t -> taskIds.contains(t.getTaskId()))
|
||||
.collect(Collectors.toList());
|
||||
return new Pair<>(tasksAuthorizedFor, bulkLog);
|
||||
return Pair.of(tasksAuthorizedFor, bulkLog);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -932,16 +932,12 @@ public class TaskServiceImpl implements TaskService {
|
|||
|
||||
List<TaskSummary> augmentTaskSummariesByContainedSummariesWithPartitioning(
|
||||
List<TaskSummaryImpl> taskSummaries) {
|
||||
|
||||
// splitting Augmentation into steps of maximal 32000 tasks
|
||||
// reason: DB2 has a maximum for parameters in a query
|
||||
List<TaskSummary> result =
|
||||
CollectionUtil.partitionBasedOnSize(taskSummaries, 32000).stream()
|
||||
return CollectionUtil.partitionBasedOnSize(taskSummaries, 32000).stream()
|
||||
.map(this::augmentTaskSummariesByContainedSummariesWithoutPartitioning)
|
||||
.flatMap(Collection::stream)
|
||||
.collect(Collectors.toList());
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private List<TaskSummaryImpl> augmentTaskSummariesByContainedSummariesWithoutPartitioning(
|
||||
|
|
|
|||
|
|
@ -2,8 +2,13 @@ package pro.taskana.task.internal;
|
|||
|
||||
import java.time.Instant;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Optional;
|
||||
import java.util.Set;
|
||||
import java.util.function.Function;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import pro.taskana.common.api.BulkOperationResults;
|
||||
|
|
@ -12,14 +17,16 @@ import pro.taskana.common.api.exceptions.NotAuthorizedException;
|
|||
import pro.taskana.common.api.exceptions.TaskanaException;
|
||||
import pro.taskana.common.internal.InternalTaskanaEngine;
|
||||
import pro.taskana.common.internal.util.IdGenerator;
|
||||
import pro.taskana.common.internal.util.ObjectAttributeChangeDetector;
|
||||
import pro.taskana.spi.history.api.events.task.TaskTransferredEvent;
|
||||
import pro.taskana.spi.history.internal.HistoryEventManager;
|
||||
import pro.taskana.task.api.TaskState;
|
||||
import pro.taskana.task.api.exceptions.InvalidStateException;
|
||||
import pro.taskana.task.api.exceptions.TaskNotFoundException;
|
||||
import pro.taskana.task.api.models.Task;
|
||||
import pro.taskana.task.internal.models.MinimalTaskSummary;
|
||||
import pro.taskana.task.api.models.TaskSummary;
|
||||
import pro.taskana.task.internal.models.TaskImpl;
|
||||
import pro.taskana.task.internal.models.TaskSummaryImpl;
|
||||
import pro.taskana.workbasket.api.WorkbasketPermission;
|
||||
import pro.taskana.workbasket.api.WorkbasketService;
|
||||
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
|
||||
|
|
@ -29,14 +36,6 @@ import pro.taskana.workbasket.internal.WorkbasketQueryImpl;
|
|||
/** This class is responsible for the transfer of Tasks to another Workbasket. */
|
||||
final class TaskTransferrer {
|
||||
|
||||
private static final String TASK_ID_LIST_NULL_OR_EMPTY = "TaskIds must not be null or empty.";
|
||||
private static final String TASK_IN_END_STATE =
|
||||
"Task '%s' is in end state and cannot be transferred.";
|
||||
private static final String TASK_NOT_FOUND = "Task '%s' was not found.";
|
||||
private static final String WORKBASKET_MARKED_FOR_DELETION =
|
||||
"Workbasket '%s' was marked for deletion.";
|
||||
private static final String WORKBASKET_WITHOUT_TRANSFER_PERMISSION =
|
||||
"Workbasket of Task '%s' got no TRANSFER permission.";
|
||||
private final InternalTaskanaEngine taskanaEngine;
|
||||
private final WorkbasketService workbasketService;
|
||||
private final TaskServiceImpl taskService;
|
||||
|
|
@ -56,7 +55,7 @@ final class TaskTransferrer {
|
|||
throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException,
|
||||
InvalidStateException {
|
||||
WorkbasketSummary destinationWorkbasket =
|
||||
workbasketService.getWorkbasket(destinationWorkbasketId);
|
||||
workbasketService.getWorkbasket(destinationWorkbasketId).asSummary();
|
||||
return transferSingleTask(taskId, destinationWorkbasket, setTransferFlag);
|
||||
}
|
||||
|
||||
|
|
@ -68,7 +67,7 @@ final class TaskTransferrer {
|
|||
throws TaskNotFoundException, WorkbasketNotFoundException, NotAuthorizedException,
|
||||
InvalidStateException {
|
||||
WorkbasketSummary destinationWorkbasket =
|
||||
workbasketService.getWorkbasket(destinationWorkbasketKey, destinationDomain);
|
||||
workbasketService.getWorkbasket(destinationWorkbasketKey, destinationDomain).asSummary();
|
||||
return transferSingleTask(taskId, destinationWorkbasket, setTransferFlag);
|
||||
}
|
||||
|
||||
|
|
@ -76,7 +75,7 @@ final class TaskTransferrer {
|
|||
List<String> taskIds, String destinationWorkbasketId, boolean setTransferFlag)
|
||||
throws NotAuthorizedException, WorkbasketNotFoundException, InvalidArgumentException {
|
||||
WorkbasketSummary destinationWorkbasket =
|
||||
workbasketService.getWorkbasket(destinationWorkbasketId);
|
||||
workbasketService.getWorkbasket(destinationWorkbasketId).asSummary();
|
||||
checkDestinationWorkbasket(destinationWorkbasket);
|
||||
|
||||
return transferMultipleTasks(taskIds, destinationWorkbasket, setTransferFlag);
|
||||
|
|
@ -89,7 +88,7 @@ final class TaskTransferrer {
|
|||
boolean setTransferFlag)
|
||||
throws NotAuthorizedException, WorkbasketNotFoundException, InvalidArgumentException {
|
||||
WorkbasketSummary destinationWorkbasket =
|
||||
workbasketService.getWorkbasket(destinationWorkbasketKey, destinationDomain);
|
||||
workbasketService.getWorkbasket(destinationWorkbasketKey, destinationDomain).asSummary();
|
||||
checkDestinationWorkbasket(destinationWorkbasket);
|
||||
|
||||
return transferMultipleTasks(taskIds, destinationWorkbasket, setTransferFlag);
|
||||
|
|
@ -99,17 +98,21 @@ final class TaskTransferrer {
|
|||
String taskId, WorkbasketSummary destinationWorkbasket, boolean setTransferFlag)
|
||||
throws NotAuthorizedException, TaskNotFoundException, WorkbasketNotFoundException,
|
||||
InvalidStateException {
|
||||
TaskImpl task = new TaskImpl();
|
||||
try {
|
||||
taskanaEngine.openConnection();
|
||||
task = (TaskImpl) taskService.getTask(taskId);
|
||||
TaskImpl task = (TaskImpl) taskService.getTask(taskId);
|
||||
TaskImpl oldTask = task.copy();
|
||||
oldTask.setId(task.getId());
|
||||
oldTask.setExternalId(task.getExternalId());
|
||||
|
||||
WorkbasketSummary originWorkbasket = task.getWorkbasketSummary();
|
||||
checkPreconditionsForTransferTask(task, destinationWorkbasket, originWorkbasket);
|
||||
|
||||
modifyTaskParameters(task, destinationWorkbasket, setTransferFlag);
|
||||
applyTransferValuesForTask(task, destinationWorkbasket, setTransferFlag);
|
||||
taskMapper.update(task);
|
||||
if (HistoryEventManager.isHistoryEnabled()) {
|
||||
createTransferredEvent(task, originWorkbasket.getId(), destinationWorkbasket.getId());
|
||||
createTransferredEvent(
|
||||
oldTask, task, originWorkbasket.getId(), destinationWorkbasket.getId());
|
||||
}
|
||||
|
||||
return task;
|
||||
|
|
@ -124,7 +127,7 @@ final class TaskTransferrer {
|
|||
boolean setTransferFlag)
|
||||
throws InvalidArgumentException {
|
||||
if (taskToBeTransferred == null || taskToBeTransferred.isEmpty()) {
|
||||
throw new InvalidArgumentException(TASK_ID_LIST_NULL_OR_EMPTY);
|
||||
throw new InvalidArgumentException("TaskIds must not be null or empty.");
|
||||
}
|
||||
BulkOperationResults<String, TaskanaException> bulkLog = new BulkOperationResults<>();
|
||||
List<String> taskIds = new ArrayList<>(taskToBeTransferred);
|
||||
|
|
@ -132,9 +135,14 @@ final class TaskTransferrer {
|
|||
try {
|
||||
taskanaEngine.openConnection();
|
||||
|
||||
List<MinimalTaskSummary> taskSummaries = taskMapper.findExistingTasks(taskIds, null);
|
||||
removeNotTransferableTasks(taskIds, taskSummaries, bulkLog);
|
||||
updateTransferableTasks(taskIds, taskSummaries, destinationWorkbasket, setTransferFlag);
|
||||
List<TaskSummary> taskSummaries =
|
||||
taskanaEngine
|
||||
.getEngine()
|
||||
.runAsAdmin(
|
||||
() -> taskService.createTaskQuery().idIn(taskIds.toArray(new String[0])).list());
|
||||
taskSummaries =
|
||||
filterOutTasksWhichDoNotMatchTransferCriteria(taskIds, taskSummaries, bulkLog);
|
||||
updateTransferableTasks(taskSummaries, destinationWorkbasket, setTransferFlag);
|
||||
|
||||
return bulkLog;
|
||||
} finally {
|
||||
|
|
@ -146,7 +154,8 @@ final class TaskTransferrer {
|
|||
Task task, WorkbasketSummary destinationWorkbasket, WorkbasketSummary originWorkbasket)
|
||||
throws NotAuthorizedException, WorkbasketNotFoundException, InvalidStateException {
|
||||
if (task.getState().isEndState()) {
|
||||
throw new InvalidStateException(String.format(TASK_IN_END_STATE, task.getId()));
|
||||
throw new InvalidStateException(
|
||||
String.format("Task '%s' is in end state and cannot be transferred.", task.getId()));
|
||||
}
|
||||
workbasketService.checkAuthorization(originWorkbasket.getId(), WorkbasketPermission.TRANSFER);
|
||||
checkDestinationWorkbasket(destinationWorkbasket);
|
||||
|
|
@ -160,101 +169,107 @@ final class TaskTransferrer {
|
|||
if (destinationWorkbasket.isMarkedForDeletion()) {
|
||||
throw new WorkbasketNotFoundException(
|
||||
destinationWorkbasket.getId(),
|
||||
String.format(WORKBASKET_MARKED_FOR_DELETION, destinationWorkbasket.getId()));
|
||||
String.format("Workbasket '%s' was marked for deletion.", destinationWorkbasket.getId()));
|
||||
}
|
||||
}
|
||||
|
||||
private void removeNotTransferableTasks(
|
||||
private List<TaskSummary> filterOutTasksWhichDoNotMatchTransferCriteria(
|
||||
List<String> taskIds,
|
||||
List<MinimalTaskSummary> taskSummaries,
|
||||
List<TaskSummary> taskSummaries,
|
||||
BulkOperationResults<String, TaskanaException> bulkLog) {
|
||||
List<WorkbasketSummary> sourceWorkbaskets =
|
||||
getSourceWorkbasketsWithTransferPermission(taskSummaries);
|
||||
|
||||
taskIds.removeIf(id -> !taskIsTransferable(id, taskSummaries, sourceWorkbaskets, bulkLog));
|
||||
taskSummaries.removeIf(task -> !taskIds.contains(task.getTaskId()));
|
||||
Map<String, TaskSummary> taskIdToTaskSummary =
|
||||
taskSummaries.stream().collect(Collectors.toMap(TaskSummary::getId, Function.identity()));
|
||||
|
||||
Set<String> workbasketIds = getSourceWorkbasketIdsWithTransferPermission(taskSummaries);
|
||||
|
||||
List<TaskSummary> filteredOutTasks = new ArrayList<>(taskIds.size());
|
||||
|
||||
for (String taskId : new HashSet<>(taskIds)) {
|
||||
TaskSummary taskSummary = taskIdToTaskSummary.get(taskId);
|
||||
Optional<TaskanaException> error =
|
||||
checkTaskForTransferCriteria(workbasketIds, taskId, taskSummary);
|
||||
if (error.isPresent()) {
|
||||
bulkLog.addError(taskId, error.get());
|
||||
} else {
|
||||
filteredOutTasks.add(taskSummary);
|
||||
}
|
||||
}
|
||||
return filteredOutTasks;
|
||||
}
|
||||
|
||||
private List<WorkbasketSummary> getSourceWorkbasketsWithTransferPermission(
|
||||
List<MinimalTaskSummary> taskSummaries) {
|
||||
Set<String> workbasketIds =
|
||||
taskSummaries.stream().map(MinimalTaskSummary::getWorkbasketId).collect(Collectors.toSet());
|
||||
private Optional<TaskanaException> checkTaskForTransferCriteria(
|
||||
Set<String> sourceWorkbasketIds, String taskId, TaskSummary taskSummary) {
|
||||
TaskanaException error = null;
|
||||
if (taskId == null || taskId.isEmpty()) {
|
||||
error = new InvalidArgumentException("TaskId should not be null or empty");
|
||||
} else if (taskSummary == null) {
|
||||
error =
|
||||
new TaskNotFoundException(
|
||||
taskId, String.format("Task with id '%s' was not found.", taskId));
|
||||
} else if (taskSummary.getState().isEndState()) {
|
||||
error =
|
||||
new InvalidStateException(
|
||||
String.format("Task in end state with id '%s' cannot be transferred.", taskId));
|
||||
} else if (!sourceWorkbasketIds.contains(taskSummary.getWorkbasketSummary().getId())) {
|
||||
error =
|
||||
new NotAuthorizedException(
|
||||
"The workbasket of this task got not TRANSFER permissions. TaskId=" + taskId,
|
||||
taskanaEngine.getEngine().getCurrentUserContext().getUserid());
|
||||
}
|
||||
return Optional.ofNullable(error);
|
||||
}
|
||||
|
||||
private Set<String> getSourceWorkbasketIdsWithTransferPermission(
|
||||
List<TaskSummary> taskSummaries) {
|
||||
if (taskSummaries.isEmpty()) {
|
||||
return Collections.emptySet();
|
||||
}
|
||||
|
||||
WorkbasketQueryImpl query = (WorkbasketQueryImpl) workbasketService.createWorkbasketQuery();
|
||||
query.setUsedToAugmentTasks(true);
|
||||
|
||||
List<WorkbasketSummary> sourceWorkbaskets = new ArrayList<>();
|
||||
if (!workbasketIds.isEmpty()) {
|
||||
sourceWorkbaskets.addAll(
|
||||
query
|
||||
.callerHasPermission(WorkbasketPermission.TRANSFER)
|
||||
.idIn(workbasketIds.toArray(new String[0]))
|
||||
.list());
|
||||
}
|
||||
return sourceWorkbaskets;
|
||||
}
|
||||
|
||||
private boolean taskIsTransferable(
|
||||
String currentTaskId,
|
||||
List<MinimalTaskSummary> taskSummaries,
|
||||
List<WorkbasketSummary> sourceWorkbaskets,
|
||||
BulkOperationResults<String, TaskanaException> bulkLog) {
|
||||
if (currentTaskId == null || currentTaskId.isEmpty()) {
|
||||
return false;
|
||||
}
|
||||
MinimalTaskSummary currentTaskSummary =
|
||||
String[] workbasketIds =
|
||||
taskSummaries.stream()
|
||||
.filter(t -> currentTaskId.equals(t.getTaskId()))
|
||||
.findFirst()
|
||||
.orElse(null);
|
||||
.map(TaskSummary::getWorkbasketSummary)
|
||||
.map(WorkbasketSummary::getId)
|
||||
.distinct()
|
||||
.toArray(String[]::new);
|
||||
|
||||
if (currentTaskSummary == null) {
|
||||
bulkLog.addError(
|
||||
currentTaskId,
|
||||
new TaskNotFoundException(currentTaskId, String.format(TASK_NOT_FOUND, currentTaskId)));
|
||||
return false;
|
||||
} else if (currentTaskSummary.getTaskState().isEndState()) {
|
||||
bulkLog.addError(
|
||||
currentTaskId,
|
||||
new InvalidStateException(String.format(TASK_IN_END_STATE, currentTaskId)));
|
||||
return false;
|
||||
} else if (sourceWorkbaskets.stream()
|
||||
.noneMatch(wb -> currentTaskSummary.getWorkbasketId().equals(wb.getId()))) {
|
||||
bulkLog.addError(
|
||||
currentTaskId,
|
||||
new NotAuthorizedException(
|
||||
String.format(WORKBASKET_WITHOUT_TRANSFER_PERMISSION, currentTaskId),
|
||||
taskanaEngine.getEngine().getCurrentUserContext().getUserid()));
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
List<WorkbasketSummary> sourceWorkbaskets =
|
||||
query.callerHasPermission(WorkbasketPermission.TRANSFER).idIn(workbasketIds).list();
|
||||
return sourceWorkbaskets.stream().map(WorkbasketSummary::getId).collect(Collectors.toSet());
|
||||
}
|
||||
|
||||
private void updateTransferableTasks(
|
||||
List<String> taskIds,
|
||||
List<MinimalTaskSummary> taskSummaries,
|
||||
List<TaskSummary> taskSummaries,
|
||||
WorkbasketSummary destinationWorkbasket,
|
||||
boolean setTransferFlag) {
|
||||
if (!taskIds.isEmpty()) {
|
||||
if (!taskSummaries.isEmpty()) {
|
||||
TaskImpl updateObject = new TaskImpl();
|
||||
modifyTaskParameters(updateObject, destinationWorkbasket, setTransferFlag);
|
||||
taskMapper.updateTransfered(taskIds, updateObject);
|
||||
applyTransferValuesForTask(updateObject, destinationWorkbasket, setTransferFlag);
|
||||
taskMapper.updateTransfered(
|
||||
taskSummaries.stream().map(TaskSummary::getId).collect(Collectors.toSet()), updateObject);
|
||||
|
||||
if (HistoryEventManager.isHistoryEnabled()) {
|
||||
taskSummaries.forEach(
|
||||
task -> {
|
||||
updateObject.setId(task.getTaskId());
|
||||
oldSummary -> {
|
||||
TaskSummaryImpl newSummary = (TaskSummaryImpl) oldSummary.copy();
|
||||
newSummary.setId(oldSummary.getId());
|
||||
newSummary.setExternalId(oldSummary.getExternalId());
|
||||
applyTransferValuesForTask(newSummary, destinationWorkbasket, setTransferFlag);
|
||||
|
||||
createTransferredEvent(
|
||||
updateObject,
|
||||
task.getWorkbasketId(),
|
||||
updateObject.getWorkbasketSummary().getId());
|
||||
oldSummary,
|
||||
newSummary,
|
||||
oldSummary.getWorkbasketSummary().getId(),
|
||||
newSummary.getWorkbasketSummary().getId());
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void modifyTaskParameters(
|
||||
TaskImpl task, WorkbasketSummary workbasket, boolean setTransferFlag) {
|
||||
private void applyTransferValuesForTask(
|
||||
TaskSummaryImpl task, WorkbasketSummary workbasket, boolean setTransferFlag) {
|
||||
task.setRead(false);
|
||||
task.setTransferred(setTransferFlag);
|
||||
task.setState(TaskState.READY);
|
||||
|
|
@ -265,13 +280,18 @@ final class TaskTransferrer {
|
|||
}
|
||||
|
||||
private void createTransferredEvent(
|
||||
Task task, String originWorkbasketId, String destinationWorkbasketId) {
|
||||
TaskSummary oldTask,
|
||||
TaskSummary newTask,
|
||||
String originWorkbasketId,
|
||||
String destinationWorkbasketId) {
|
||||
String details = ObjectAttributeChangeDetector.determineChangesInAttributes(oldTask, newTask);
|
||||
historyEventManager.createEvent(
|
||||
new TaskTransferredEvent(
|
||||
IdGenerator.generateWithPrefix(IdGenerator.ID_PREFIX_TASK_HISTORY_EVENT),
|
||||
task,
|
||||
newTask,
|
||||
originWorkbasketId,
|
||||
destinationWorkbasketId,
|
||||
taskanaEngine.getEngine().getCurrentUserContext().getUserid()));
|
||||
taskanaEngine.getEngine().getCurrentUserContext().getUserid(),
|
||||
details));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ import pro.taskana.task.api.models.TaskSummary;
|
|||
import pro.taskana.workbasket.api.models.WorkbasketSummary;
|
||||
import pro.taskana.workbasket.internal.models.WorkbasketSummaryImpl;
|
||||
|
||||
/** Entity which contains the most important informations about a Task. */
|
||||
/** Entity which contains the most important information about a Task. */
|
||||
public class TaskSummaryImpl implements TaskSummary {
|
||||
|
||||
protected String id;
|
||||
|
|
|
|||
|
|
@ -276,23 +276,22 @@ class QueryTasksAccTest extends AbstractAccTest {
|
|||
Stream<DynamicTest> testQueryForCustomX() {
|
||||
List<Triplet<TaskCustomField, String[], Integer>> list =
|
||||
List.of(
|
||||
new Triplet<>(
|
||||
TaskCustomField.CUSTOM_1, new String[] {"custom%", "p%", "%xyz%", "efg"}, 3),
|
||||
new Triplet<>(TaskCustomField.CUSTOM_2, new String[] {"custom%", "a%"}, 2),
|
||||
new Triplet<>(TaskCustomField.CUSTOM_3, new String[] {"ffg"}, 1),
|
||||
new Triplet<>(TaskCustomField.CUSTOM_4, new String[] {"%ust%", "%ty"}, 2),
|
||||
new Triplet<>(TaskCustomField.CUSTOM_5, new String[] {"ew", "al"}, 6),
|
||||
new Triplet<>(TaskCustomField.CUSTOM_6, new String[] {"%custom6%", "%vvg%", "11%"}, 5),
|
||||
new Triplet<>(TaskCustomField.CUSTOM_7, new String[] {"%"}, 2),
|
||||
new Triplet<>(TaskCustomField.CUSTOM_8, new String[] {"%"}, 2),
|
||||
new Triplet<>(TaskCustomField.CUSTOM_9, new String[] {"%"}, 2),
|
||||
new Triplet<>(TaskCustomField.CUSTOM_10, new String[] {"%"}, 3),
|
||||
new Triplet<>(TaskCustomField.CUSTOM_11, new String[] {"%"}, 3),
|
||||
new Triplet<>(TaskCustomField.CUSTOM_12, new String[] {"%"}, 3),
|
||||
new Triplet<>(TaskCustomField.CUSTOM_13, new String[] {"%"}, 3),
|
||||
new Triplet<>(TaskCustomField.CUSTOM_14, new String[] {"%"}, 88),
|
||||
new Triplet<>(TaskCustomField.CUSTOM_15, new String[] {"%"}, 3),
|
||||
new Triplet<>(TaskCustomField.CUSTOM_16, new String[] {"%"}, 3));
|
||||
Triplet.of(TaskCustomField.CUSTOM_1, new String[] {"custom%", "p%", "%xyz%", "efg"}, 3),
|
||||
Triplet.of(TaskCustomField.CUSTOM_2, new String[] {"custom%", "a%"}, 2),
|
||||
Triplet.of(TaskCustomField.CUSTOM_3, new String[] {"ffg"}, 1),
|
||||
Triplet.of(TaskCustomField.CUSTOM_4, new String[] {"%ust%", "%ty"}, 2),
|
||||
Triplet.of(TaskCustomField.CUSTOM_5, new String[] {"ew", "al"}, 6),
|
||||
Triplet.of(TaskCustomField.CUSTOM_6, new String[] {"%custom6%", "%vvg%", "11%"}, 5),
|
||||
Triplet.of(TaskCustomField.CUSTOM_7, new String[] {"%"}, 2),
|
||||
Triplet.of(TaskCustomField.CUSTOM_8, new String[] {"%"}, 2),
|
||||
Triplet.of(TaskCustomField.CUSTOM_9, new String[] {"%"}, 2),
|
||||
Triplet.of(TaskCustomField.CUSTOM_10, new String[] {"%"}, 3),
|
||||
Triplet.of(TaskCustomField.CUSTOM_11, new String[] {"%"}, 3),
|
||||
Triplet.of(TaskCustomField.CUSTOM_12, new String[] {"%"}, 3),
|
||||
Triplet.of(TaskCustomField.CUSTOM_13, new String[] {"%"}, 3),
|
||||
Triplet.of(TaskCustomField.CUSTOM_14, new String[] {"%"}, 88),
|
||||
Triplet.of(TaskCustomField.CUSTOM_15, new String[] {"%"}, 3),
|
||||
Triplet.of(TaskCustomField.CUSTOM_16, new String[] {"%"}, 3));
|
||||
assertThat(list).hasSameSizeAs(TaskCustomField.values());
|
||||
|
||||
return DynamicTest.stream(
|
||||
|
|
|
|||
|
|
@ -7,8 +7,8 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
|
|||
import acceptance.AbstractAccTest;
|
||||
import java.time.Instant;
|
||||
import java.time.temporal.ChronoUnit;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
|
@ -34,21 +34,18 @@ import pro.taskana.workbasket.api.models.Workbasket;
|
|||
@ExtendWith(JaasExtension.class)
|
||||
class TransferTaskAccTest extends AbstractAccTest {
|
||||
|
||||
TransferTaskAccTest() {
|
||||
super();
|
||||
}
|
||||
private static final TaskService TASK_SERVICE = taskanaEngine.getTaskService();
|
||||
|
||||
@WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
|
||||
@Test
|
||||
void should_TransferTaskToWorkbasket_When_WorkbasketIdIsProvided() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:000000000000000000000000000000000003");
|
||||
taskService.claim(task.getId());
|
||||
taskService.setTaskRead(task.getId(), true);
|
||||
Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
|
||||
TASK_SERVICE.claim(task.getId());
|
||||
TASK_SERVICE.setTaskRead(task.getId(), true);
|
||||
|
||||
taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000006");
|
||||
TASK_SERVICE.transfer(task.getId(), "WBI:100000000000000000000000000000000006");
|
||||
|
||||
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000003");
|
||||
Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
|
||||
assertThat(transferredTask).isNotNull();
|
||||
assertThat(transferredTask.isTransferred()).isTrue();
|
||||
assertThat(transferredTask.isRead()).isFalse();
|
||||
|
|
@ -60,14 +57,13 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
@TestTemplate
|
||||
void should_TransferTask_When_NoExplicitPermissionsButUserIsInAdministrativeRole()
|
||||
throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:000000000000000000000000000000000003");
|
||||
taskService.claim(task.getId());
|
||||
taskService.setTaskRead(task.getId(), true);
|
||||
Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
|
||||
TASK_SERVICE.claim(task.getId());
|
||||
TASK_SERVICE.setTaskRead(task.getId(), true);
|
||||
|
||||
taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000006");
|
||||
TASK_SERVICE.transfer(task.getId(), "WBI:100000000000000000000000000000000006");
|
||||
|
||||
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000003");
|
||||
Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
|
||||
assertThat(transferredTask).isNotNull();
|
||||
assertThat(transferredTask.isTransferred()).isTrue();
|
||||
assertThat(transferredTask.isRead()).isFalse();
|
||||
|
|
@ -77,14 +73,13 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
@WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
|
||||
@Test
|
||||
void should_TransferTaskToWorkbasket_When_WorkbasketKeyAndDomainIsProvided() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:000000000000000000000000000000000003");
|
||||
taskService.claim(task.getId());
|
||||
taskService.setTaskRead(task.getId(), true);
|
||||
Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
|
||||
TASK_SERVICE.claim(task.getId());
|
||||
TASK_SERVICE.setTaskRead(task.getId(), true);
|
||||
|
||||
taskService.transfer(task.getId(), "USER-1-1", "DOMAIN_A");
|
||||
TASK_SERVICE.transfer(task.getId(), "USER-1-1", "DOMAIN_A");
|
||||
|
||||
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000003");
|
||||
Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
|
||||
assertThat(transferredTask).isNotNull();
|
||||
assertThat(transferredTask.isTransferred()).isTrue();
|
||||
assertThat(transferredTask.isRead()).isFalse();
|
||||
|
|
@ -94,11 +89,10 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
@WithAccessId(user = "user-1-1", groups = GROUP_1_DN)
|
||||
@Test
|
||||
void should_ChangeDomain_When_TransferringTaskToWorkbasketWithDifferentDomain() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:000000000000000000000000000000000000");
|
||||
Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000000");
|
||||
String domain1 = task.getDomain();
|
||||
|
||||
Task transferredTask = taskService.transfer(task.getId(), "GPK_B_KSC_1", "DOMAIN_B");
|
||||
Task transferredTask = TASK_SERVICE.transfer(task.getId(), "GPK_B_KSC_1", "DOMAIN_B");
|
||||
|
||||
assertThat(transferredTask).isNotNull();
|
||||
assertThat(transferredTask.getDomain()).isNotEqualTo(domain1);
|
||||
|
|
@ -107,54 +101,40 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
@WithAccessId(user = "user-1-1")
|
||||
@Test
|
||||
void should_ThrowException_When_UserHasNoTransferAuthorization() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:000000000000000000000000000000000001");
|
||||
Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000001");
|
||||
|
||||
ThrowingCallable call =
|
||||
() -> {
|
||||
taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000005");
|
||||
};
|
||||
() -> TASK_SERVICE.transfer(task.getId(), "WBI:100000000000000000000000000000000005");
|
||||
assertThatThrownBy(call).isInstanceOf(NotAuthorizedException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
|
||||
@Test
|
||||
void should_ThrowException_When_DestinationWorkbasketDoesNotExist() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:000000000000000000000000000000000003");
|
||||
taskService.claim(task.getId());
|
||||
taskService.setTaskRead(task.getId(), true);
|
||||
Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
|
||||
TASK_SERVICE.claim(task.getId());
|
||||
TASK_SERVICE.setTaskRead(task.getId(), true);
|
||||
|
||||
ThrowingCallable call =
|
||||
() -> {
|
||||
taskService.transfer(task.getId(), "INVALID");
|
||||
};
|
||||
ThrowingCallable call = () -> TASK_SERVICE.transfer(task.getId(), "INVALID");
|
||||
assertThatThrownBy(call).isInstanceOf(WorkbasketNotFoundException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "teamlead-1")
|
||||
@Test
|
||||
void should_ThrowException_When_TaskToTransferDoesNotExist() {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
|
||||
ThrowingCallable call =
|
||||
() -> {
|
||||
taskService.transfer("Invalid", "WBI:100000000000000000000000000000000005");
|
||||
};
|
||||
() -> TASK_SERVICE.transfer("Invalid", "WBI:100000000000000000000000000000000005");
|
||||
assertThatThrownBy(call).isInstanceOf(TaskNotFoundException.class);
|
||||
}
|
||||
|
||||
@WithAccessId(user = "teamlead-1")
|
||||
@Test
|
||||
void should_ThrowException_When_TransferWithNoTransferAuthorization() {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
|
||||
ThrowingCallable call =
|
||||
() -> {
|
||||
taskService.transfer(
|
||||
() ->
|
||||
TASK_SERVICE.transfer(
|
||||
"TKI:200000000000000000000000000000000007",
|
||||
"WBI:100000000000000000000000000000000001");
|
||||
};
|
||||
assertThatThrownBy(call)
|
||||
.isInstanceOf(NotAuthorizedException.class)
|
||||
.extracting(Throwable::getMessage)
|
||||
|
|
@ -167,13 +147,10 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
@WithAccessId(user = "user-1-1", groups = GROUP_1_DN)
|
||||
@Test
|
||||
void should_ThrowException_When_TransferWithNoAppendAuthorization() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:000000000000000000000000000000000002");
|
||||
Task task = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000002");
|
||||
|
||||
ThrowingCallable call =
|
||||
() -> {
|
||||
taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000008");
|
||||
};
|
||||
() -> TASK_SERVICE.transfer(task.getId(), "WBI:100000000000000000000000000000000008");
|
||||
assertThatThrownBy(call)
|
||||
.isInstanceOf(NotAuthorizedException.class)
|
||||
.extracting(Throwable::getMessage)
|
||||
|
|
@ -186,13 +163,10 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
@WithAccessId(user = "teamlead-1")
|
||||
@Test
|
||||
void should_ThrowException_When_TaskToTransferIsAlreadyCompleted() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
Task task = taskService.getTask("TKI:100000000000000000000000000000000006");
|
||||
Task task = TASK_SERVICE.getTask("TKI:100000000000000000000000000000000006");
|
||||
|
||||
ThrowingCallable call =
|
||||
() -> {
|
||||
taskService.transfer(task.getId(), "WBI:100000000000000000000000000000000005");
|
||||
};
|
||||
() -> TASK_SERVICE.transfer(task.getId(), "WBI:100000000000000000000000000000000005");
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidStateException.class);
|
||||
}
|
||||
|
||||
|
|
@ -200,18 +174,17 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
@Test
|
||||
void should_BulkTransferTasks_When_WorkbasketIdIsProvided() throws Exception {
|
||||
final Instant before = Instant.now().truncatedTo(ChronoUnit.MILLIS);
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
ArrayList<String> taskIdList = new ArrayList<>();
|
||||
taskIdList.add("TKI:000000000000000000000000000000000004");
|
||||
taskIdList.add("TKI:000000000000000000000000000000000005");
|
||||
List<String> taskIdList =
|
||||
List.of(
|
||||
"TKI:000000000000000000000000000000000004", "TKI:000000000000000000000000000000000005");
|
||||
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskService.transferTasks("WBI:100000000000000000000000000000000006", taskIdList);
|
||||
TASK_SERVICE.transferTasks("WBI:100000000000000000000000000000000006", taskIdList);
|
||||
assertThat(results.containsErrors()).isFalse();
|
||||
|
||||
final Workbasket wb =
|
||||
taskanaEngine.getWorkbasketService().getWorkbasket("USER-1-1", "DOMAIN_A");
|
||||
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000004");
|
||||
Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000004");
|
||||
assertThat(transferredTask).isNotNull();
|
||||
assertThat(transferredTask.isTransferred()).isTrue();
|
||||
assertThat(transferredTask.isRead()).isFalse();
|
||||
|
|
@ -220,7 +193,7 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
assertThat(transferredTask.getDomain()).isEqualTo(wb.getDomain());
|
||||
assertThat(transferredTask.getModified().isBefore(before)).isFalse();
|
||||
assertThat(transferredTask.getOwner()).isNull();
|
||||
transferredTask = taskService.getTask("TKI:000000000000000000000000000000000005");
|
||||
transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000005");
|
||||
assertThat(transferredTask).isNotNull();
|
||||
assertThat(transferredTask.isTransferred()).isTrue();
|
||||
assertThat(transferredTask.isRead()).isFalse();
|
||||
|
|
@ -235,24 +208,26 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
@Test
|
||||
void should_BulkTransferOnlyValidTasks_When_SomeTasksToTransferCauseExceptions()
|
||||
throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
final Workbasket wb =
|
||||
taskanaEngine.getWorkbasketService().getWorkbasket("USER-1-1", "DOMAIN_A");
|
||||
final Instant before = Instant.now().truncatedTo(ChronoUnit.MILLIS);
|
||||
ArrayList<String> taskIdList = new ArrayList<>();
|
||||
taskIdList.add("TKI:000000000000000000000000000000000006"); // working
|
||||
taskIdList.add("TKI:000000000000000000000000000000000041"); // NotAuthorized READ
|
||||
taskIdList.add("TKI:200000000000000000000000000000000008"); // NotAuthorized TRANSFER
|
||||
taskIdList.add(""); // InvalidArgument
|
||||
taskIdList.add(null); // InvalidArgument
|
||||
taskIdList.add("TKI:000000000000000000000000000000000099"); // not existing
|
||||
taskIdList.add("TKI:100000000000000000000000000000000006"); // already completed
|
||||
// we can't use List.of because of the null value we insert
|
||||
List<String> taskIdList =
|
||||
Arrays.asList(
|
||||
"TKI:000000000000000000000000000000000006", // working
|
||||
"TKI:000000000000000000000000000000000041", // NotAuthorized READ
|
||||
"TKI:000000000000000000000000000000000041", // NotAuthorized READ
|
||||
"TKI:200000000000000000000000000000000008", // NotAuthorized TRANSFER
|
||||
"", // InvalidArgument
|
||||
null, // InvalidArgument
|
||||
"TKI:000000000000000000000000000000000099", // not existing
|
||||
"TKI:100000000000000000000000000000000006"); // already completed
|
||||
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskService.transferTasks("WBI:100000000000000000000000000000000006", taskIdList);
|
||||
TASK_SERVICE.transferTasks("WBI:100000000000000000000000000000000006", taskIdList);
|
||||
// check for exceptions in bulk
|
||||
assertThat(results.containsErrors()).isTrue();
|
||||
assertThat(results.getErrorMap().values()).hasSize(4);
|
||||
assertThat(results.getErrorMap().values()).hasSize(6);
|
||||
assertThat(results.getErrorForId("TKI:000000000000000000000000000000000041").getClass())
|
||||
.isEqualTo(NotAuthorizedException.class);
|
||||
assertThat(results.getErrorForId("TKI:200000000000000000000000000000000008").getClass())
|
||||
|
|
@ -261,9 +236,11 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
.isEqualTo(TaskNotFoundException.class);
|
||||
assertThat(results.getErrorForId("TKI:100000000000000000000000000000000006").getClass())
|
||||
.isEqualTo(InvalidStateException.class);
|
||||
assertThat(results.getErrorForId("").getClass()).isEqualTo(InvalidArgumentException.class);
|
||||
assertThat(results.getErrorForId(null).getClass()).isEqualTo(InvalidArgumentException.class);
|
||||
|
||||
// verify valid requests
|
||||
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000006");
|
||||
Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000006");
|
||||
assertThat(transferredTask).isNotNull();
|
||||
assertThat(transferredTask.isTransferred()).isTrue();
|
||||
assertThat(transferredTask.isRead()).isFalse();
|
||||
|
|
@ -273,12 +250,12 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
assertThat(transferredTask.getModified().isBefore(before)).isFalse();
|
||||
assertThat(transferredTask.getOwner()).isNull();
|
||||
|
||||
transferredTask = taskService.getTask("TKI:200000000000000000000000000000000008");
|
||||
transferredTask = TASK_SERVICE.getTask("TKI:200000000000000000000000000000000008");
|
||||
assertThat(transferredTask).isNotNull();
|
||||
assertThat(transferredTask.isTransferred()).isFalse();
|
||||
assertThat(transferredTask.getWorkbasketKey()).isEqualTo("TPK_VIP");
|
||||
|
||||
transferredTask = taskService.getTask("TKI:100000000000000000000000000000000006");
|
||||
transferredTask = TASK_SERVICE.getTask("TKI:100000000000000000000000000000000006");
|
||||
assertThat(transferredTask).isNotNull();
|
||||
assertThat(transferredTask.isTransferred()).isFalse();
|
||||
assertThat(transferredTask.getWorkbasketKey()).isEqualTo("TEAMLEAD-1");
|
||||
|
|
@ -287,15 +264,14 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
@WithAccessId(user = "teamlead-1")
|
||||
@Test
|
||||
void should_ThrowException_When_BulkTransferTasksWithoutAppendPermissionOnTarget() {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
ArrayList<String> taskIdList = new ArrayList<>();
|
||||
taskIdList.add("TKI:000000000000000000000000000000000006"); // working
|
||||
taskIdList.add("TKI:000000000000000000000000000000000041"); // NotAuthorized READ
|
||||
|
||||
List<String> taskIdList =
|
||||
List.of(
|
||||
"TKI:000000000000000000000000000000000006", // working
|
||||
"TKI:000000000000000000000000000000000041"); // NotAuthorized READ
|
||||
|
||||
ThrowingCallable call =
|
||||
() -> {
|
||||
taskService.transferTasks("WBI:100000000000000000000000000000000010", taskIdList);
|
||||
};
|
||||
() -> TASK_SERVICE.transferTasks("WBI:100000000000000000000000000000000010", taskIdList);
|
||||
assertThatThrownBy(call)
|
||||
.isInstanceOf(NotAuthorizedException.class)
|
||||
.hasMessageContaining("APPEND");
|
||||
|
|
@ -304,13 +280,10 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
@WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
|
||||
@Test
|
||||
void should_TransferTasks_When_TransferringTasksWithListNotSupportingRemove() {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
List<String> taskIds = List.of("TKI:000000000000000000000000000000000006");
|
||||
|
||||
ThrowingCallable call =
|
||||
() -> {
|
||||
taskService.transferTasks("WBI:100000000000000000000000000000000006", taskIds);
|
||||
};
|
||||
() -> TASK_SERVICE.transferTasks("WBI:100000000000000000000000000000000006", taskIds);
|
||||
|
||||
assertThatCode(call).doesNotThrowAnyException();
|
||||
}
|
||||
|
|
@ -318,39 +291,20 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
@WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
|
||||
@Test
|
||||
void should_ThrowException_When_TransferredTaskListIsNull() {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
// test with invalid list
|
||||
|
||||
ThrowingCallable call =
|
||||
() -> taskService.transferTasks("WBI:100000000000000000000000000000000006", null);
|
||||
() -> TASK_SERVICE.transferTasks("WBI:100000000000000000000000000000000006", null);
|
||||
assertThatThrownBy(call)
|
||||
.isInstanceOf(InvalidArgumentException.class)
|
||||
.hasMessage("TaskIds must not be null or empty.");
|
||||
}
|
||||
|
||||
@WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
|
||||
@Test
|
||||
void should_ThrowException_When_TransferringTasksWithOnlyInvalidTasksIds() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
|
||||
// test with list containing only invalid arguments
|
||||
BulkOperationResults<String, TaskanaException> bulklog =
|
||||
taskService.transferTasks(
|
||||
"WBI:100000000000000000000000000000000006",
|
||||
/* we can't use List.of because of the null value we insert */
|
||||
Arrays.asList("", "", "", null));
|
||||
assertThat(bulklog.getFailedIds()).isEmpty();
|
||||
}
|
||||
|
||||
@WithAccessId(user = "teamlead-1", groups = GROUP_1_DN)
|
||||
@Test
|
||||
void should_ThrowException_When_TransferringEmptyTaskIdList() {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
List<String> taskIds = new ArrayList<>();
|
||||
ThrowingCallable call =
|
||||
() -> {
|
||||
taskService.transferTasks("WBI:100000000000000000000000000000000006", taskIds);
|
||||
};
|
||||
() ->
|
||||
TASK_SERVICE.transferTasks(
|
||||
"WBI:100000000000000000000000000000000006", Collections.emptyList());
|
||||
assertThatThrownBy(call).isInstanceOf(InvalidArgumentException.class);
|
||||
}
|
||||
|
||||
|
|
@ -358,19 +312,17 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
@Test
|
||||
void should_BulkTransferTasks_When_WorkbasketKeyAndDomainIsProvided() throws Exception {
|
||||
final Instant before = Instant.now().truncatedTo(ChronoUnit.MILLIS);
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
List<String> taskIdList = new ArrayList<>();
|
||||
|
||||
taskIdList.add("TKI:000000000000000000000000000000000023");
|
||||
taskIdList.add("TKI:000000000000000000000000000000000024");
|
||||
List<String> taskIdList =
|
||||
List.of(
|
||||
"TKI:000000000000000000000000000000000023", "TKI:000000000000000000000000000000000024");
|
||||
|
||||
BulkOperationResults<String, TaskanaException> results =
|
||||
taskService.transferTasks("GPK_B_KSC_1", "DOMAIN_B", taskIdList);
|
||||
TASK_SERVICE.transferTasks("GPK_B_KSC_1", "DOMAIN_B", taskIdList);
|
||||
assertThat(results.containsErrors()).isFalse();
|
||||
|
||||
final Workbasket wb =
|
||||
taskanaEngine.getWorkbasketService().getWorkbasket("GPK_B_KSC_1", "DOMAIN_B");
|
||||
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000023");
|
||||
Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000023");
|
||||
assertThat(transferredTask).isNotNull();
|
||||
assertThat(transferredTask.isTransferred()).isTrue();
|
||||
assertThat(transferredTask.isRead()).isFalse();
|
||||
|
|
@ -379,7 +331,7 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
assertThat(transferredTask.getDomain()).isEqualTo(wb.getDomain());
|
||||
assertThat(transferredTask.getModified().isBefore(before)).isFalse();
|
||||
assertThat(transferredTask.getOwner()).isNull();
|
||||
transferredTask = taskService.getTask("TKI:000000000000000000000000000000000024");
|
||||
transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000024");
|
||||
assertThat(transferredTask).isNotNull();
|
||||
assertThat(transferredTask.isTransferred()).isTrue();
|
||||
assertThat(transferredTask.isRead()).isFalse();
|
||||
|
|
@ -393,13 +345,12 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
@WithAccessId(user = "admin")
|
||||
@Test
|
||||
void should_NotSetTheTransferFlag_When_SetTransferFlagNotRequested() throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
taskService.transfer(
|
||||
TASK_SERVICE.transfer(
|
||||
"TKI:000000000000000000000000000000000003",
|
||||
"WBI:100000000000000000000000000000000006",
|
||||
false);
|
||||
|
||||
Task transferredTask = taskService.getTask("TKI:000000000000000000000000000000000003");
|
||||
Task transferredTask = TASK_SERVICE.getTask("TKI:000000000000000000000000000000000003");
|
||||
assertThat(transferredTask).isNotNull();
|
||||
assertThat(transferredTask.isTransferred()).isFalse();
|
||||
}
|
||||
|
|
@ -408,8 +359,7 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
@Test
|
||||
void should_NotSetTheTransferFlagWithinBulkTransfer_When_SetTransferFlagNotRequested()
|
||||
throws Exception {
|
||||
TaskService taskService = taskanaEngine.getTaskService();
|
||||
taskService.transferTasks(
|
||||
TASK_SERVICE.transferTasks(
|
||||
"WBI:100000000000000000000000000000000006",
|
||||
List.of(
|
||||
"TKI:000000000000000000000000000000000003",
|
||||
|
|
@ -418,7 +368,7 @@ class TransferTaskAccTest extends AbstractAccTest {
|
|||
false);
|
||||
|
||||
List<TaskSummary> transferredTasks =
|
||||
taskService
|
||||
TASK_SERVICE
|
||||
.createTaskQuery()
|
||||
.idIn(
|
||||
"TKI:000000000000000000000000000000000004",
|
||||
|
|
|
|||
Loading…
Reference in New Issue