nosu
/
taskana
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

TSK-1727: + TSK-1624: Add notLike and notIn filter parameter to TaskQuery

This commit is contained in:
Lia Lissmann 2021-09-09 11:43:21 +02:00 committed by LiaLissmann
parent 5e4314fc19
commit 1bab31e43c
23 changed files with 7279 additions and 2771 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
common/taskana-common/src/main/java/pro/taskana/common/internal/util/SqlProviderUtil.java
View File

@ -57,6 +57,24 @@ public class SqlProviderUtil {
return whereInTime(collection, column, new StringBuilder());
}
public static StringBuilder whereNotInTime(String collection, String column, StringBuilder sb) {
return sb.append("<if test='")
.append(collection)
.append(" !=null'> AND (<foreach item='item' collection='")
.append(collection)
.append("' separator=' OR ' > ( <if test='item.begin!=null'> ")
.append(column)
.append(
" &lt; #{item.begin} </if> <if test='item.begin!=null and item.end!=null'> OR"
+ " </if><if test='item.end!=null'> ")
.append(column)
.append(" &gt; #{item.end} </if>)</foreach>)</if> ");
}
public static StringBuilder whereNotInTime(String collection, String column) {
return whereNotInTime(collection, column, new StringBuilder());
}
public static StringBuilder whereLike(String collection, String column, StringBuilder sb) {
return sb.append("<if test='")
.append(collection)
@ -71,6 +89,20 @@ public class SqlProviderUtil {
return whereLike(collection, column, new StringBuilder());
}
public static StringBuilder whereNotLike(String collection, String column, StringBuilder sb) {
return sb.append("<if test='")
.append(collection)
.append(" != null'>AND (<foreach item='item' collection='")
.append(collection)
.append("' separator=' OR '>UPPER(")
.append(column)
.append(") NOT LIKE #{item}</foreach>)</if> ");
}
public static StringBuilder whereNotLike(String collection, String column) {
return whereNotLike(collection, column, new StringBuilder());
}
public static StringBuilder whereCustomStatements(
String baseCollection, String baseColumn, int customBound, StringBuilder sb) {
IntStream.rangeClosed(1, customBound)
@ -78,8 +110,9 @@ public class SqlProviderUtil {
x -> {
String column = baseColumn + "_" + x;
whereIn(baseCollection + x + "In", column, sb);
whereLike(baseCollection + x + "Like", column, sb);
whereNotIn(baseCollection + x + "NotIn", column, sb);
whereLike(baseCollection + x + "Like", column, sb);
whereNotLike(baseCollection + x + "NotLike", column, sb);
});
return sb;
}

12
lib/taskana-core/src/main/java/pro/taskana/classification/internal/builder/ClassificationBuilder.java
View File

@ -11,6 +11,7 @@ import pro.taskana.classification.api.exceptions.ClassificationAlreadyExistExcep
import pro.taskana.classification.api.exceptions.ClassificationNotFoundException;
import pro.taskana.classification.api.exceptions.MalformedServiceLevelException;
import pro.taskana.classification.api.models.Classification;
import pro.taskana.classification.api.models.ClassificationSummary;
import pro.taskana.common.api.exceptions.DomainNotFoundException;
import pro.taskana.common.api.exceptions.InvalidArgumentException;
import pro.taskana.common.api.exceptions.NotAuthorizedException;
@ -132,4 +133,15 @@ public class ClassificationBuilder {
return Subject.doAs(subject, performBuildAndStore);
}
public ClassificationSummary buildAndStoreAsSummary(ClassificationService classificationService)
throws InvalidArgumentException, ClassificationAlreadyExistException, DomainNotFoundException,
MalformedServiceLevelException, NotAuthorizedException, ClassificationNotFoundException {
return buildAndStore(classificationService).asSummary();
}
public ClassificationSummary buildAndStoreAsSummary(
ClassificationService classificationService, String userId) throws PrivilegedActionException {
return buildAndStore(classificationService, userId).asSummary();
}
}

24
lib/taskana-core/src/main/java/pro/taskana/monitor/internal/MonitorMapperSqlProvider.java
View File

@ -4,10 +4,12 @@ import static pro.taskana.common.internal.util.SqlProviderUtil.CLOSING_SCRIPT_TA
import static pro.taskana.common.internal.util.SqlProviderUtil.CLOSING_WHERE_TAG;
import static pro.taskana.common.internal.util.SqlProviderUtil.OPENING_SCRIPT_TAG;
import static pro.taskana.common.internal.util.SqlProviderUtil.OPENING_WHERE_TAG;
import static pro.taskana.common.internal.util.SqlProviderUtil.whereCustomStatements;
import static pro.taskana.common.internal.util.SqlProviderUtil.whereIn;
import static pro.taskana.common.internal.util.SqlProviderUtil.whereLike;
import static pro.taskana.common.internal.util.SqlProviderUtil.whereNotIn;
import java.util.stream.IntStream;
import pro.taskana.common.internal.util.SqlProviderUtil;
public class MonitorMapperSqlProvider {
@ -281,6 +283,24 @@ public class MonitorMapperSqlProvider {
+ CLOSING_SCRIPT_TAG;
}
private static StringBuilder whereCustomStatements(
String baseCollection, String baseColumn, int customBound, StringBuilder sb) {
IntStream.rangeClosed(1, customBound)
.forEach(
x -> {
String column = baseColumn + "_" + x;
whereIn(baseCollection + x + "In", column, sb);
whereNotIn(baseCollection + x + "NotIn", column, sb);
whereLike(baseCollection + x + "Like", column, sb);
});
return sb;
}
private static StringBuilder whereCustomStatements(
String baseCollection, String baseColumn, int customBound) {
return whereCustomStatements(baseCollection, baseColumn, customBound, new StringBuilder());
}
private static StringBuilder timeIntervalWhereStatements() {
StringBuilder sb = new StringBuilder();
SqlProviderUtil.whereIn("report.workbasketIds", "T.WORKBASKET_ID", sb);
@ -289,7 +309,7 @@ public class MonitorMapperSqlProvider {
SqlProviderUtil.whereIn("report.domains", "T.DOMAIN", sb);
SqlProviderUtil.whereIn("report.classificationIds", "T.CLASSIFICATION_ID", sb);
SqlProviderUtil.whereNotIn("report.excludedClassificationIds", "T.CLASSIFICATION_ID", sb);
SqlProviderUtil.whereCustomStatements("report.custom", "T.CUSTOM", 16, sb);
whereCustomStatements("report.custom", "T.CUSTOM", 16, sb);
return sb;
}
}

1579
lib/taskana-core/src/main/java/pro/taskana/task/api/TaskQuery.java
View File

File diff suppressed because it is too large Load Diff

2661
lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskQueryImpl.java
View File

File diff suppressed because it is too large Load Diff

154
lib/taskana-core/src/main/java/pro/taskana/task/internal/TaskQuerySqlProvider.java
View File

@ -10,6 +10,8 @@ import static pro.taskana.common.internal.util.SqlProviderUtil.whereIn;
import static pro.taskana.common.internal.util.SqlProviderUtil.whereInTime;
import static pro.taskana.common.internal.util.SqlProviderUtil.whereLike;
import static pro.taskana.common.internal.util.SqlProviderUtil.whereNotIn;
import static pro.taskana.common.internal.util.SqlProviderUtil.whereNotInTime;
import static pro.taskana.common.internal.util.SqlProviderUtil.whereNotLike;
import java.util.Arrays;
import java.util.stream.Collectors;
@ -17,14 +19,6 @@ import java.util.stream.Collectors;
import pro.taskana.task.api.TaskQueryColumnName;
public class TaskQuerySqlProvider {
private static final String WILDCARD_LIKE_STATEMENT =
"<if test='wildcardSearchValueLike != null and wildcardSearchFieldIn != null'>AND ("
+ "<foreach item='item' collection='wildcardSearchFieldIn' separator=' OR '>"
+ "UPPER(t.${item}) "
+ "LIKE #{wildcardSearchValueLike}"
+ "</foreach>)"
+ "</if> ";
private TaskQuerySqlProvider() {}
@SuppressWarnings("unused")
@ -54,8 +48,6 @@ public class TaskQuerySqlProvider {
+ OPENING_WHERE_TAG
+ checkForAuthorization()
+ commonTaskWhereStatement()
+ WILDCARD_LIKE_STATEMENT
+ commonTaskObjectReferenceWhereStatement()
+ "<if test='selectAndClaim == true'> AND t.STATE = 'READY' </if>"
+ CLOSING_WHERE_TAG
+ "<if test='!orderBy.isEmpty()'>"
@ -97,8 +89,6 @@ public class TaskQuerySqlProvider {
+ "</if>"
+ OPENING_WHERE_TAG
+ commonTaskWhereStatement()
+ commonTaskObjectReferenceWhereStatement()
+ WILDCARD_LIKE_STATEMENT
+ CLOSING_WHERE_TAG
+ "), Y ("
+ db2selectFields()
@ -146,8 +136,6 @@ public class TaskQuerySqlProvider {
+ OPENING_WHERE_TAG
+ checkForAuthorization()
+ commonTaskWhereStatement()
+ commonTaskObjectReferenceWhereStatement()
+ WILDCARD_LIKE_STATEMENT
+ CLOSING_WHERE_TAG
+ CLOSING_SCRIPT_TAG;
}
@ -169,8 +157,6 @@ public class TaskQuerySqlProvider {
+ "</if>"
+ OPENING_WHERE_TAG
+ commonTaskWhereStatement()
+ commonTaskObjectReferenceWhereStatement()
+ WILDCARD_LIKE_STATEMENT
+ CLOSING_WHERE_TAG
+ "), Y (ID, FLAG) AS ("
+ "SELECT ID, ("
@ -305,71 +291,93 @@ public class TaskQuerySqlProvider {
+ "</if>";
}
private static String commonTaskWhereStatement() {
private static void commonWhereClauses(String filter, String channel, StringBuilder sb) {
whereIn(filter + "In", channel, sb);
whereNotIn(filter + "NotIn", channel, sb);
whereLike(filter + "Like", channel, sb);
whereNotLike(filter + "NotLike", channel, sb);
}
private static StringBuilder commonTaskWhereStatement() {
StringBuilder sb = new StringBuilder();
whereIn("taskIds", "t.ID", sb);
whereIn("priority", "PRIORITY", sb);
whereIn("externalIdIn", "t.EXTERNAL_ID", sb);
whereIn("nameIn", "t.NAME", sb);
whereIn("creatorIn", "CREATOR", sb);
whereIn("stateIn", "STATE", sb);
whereIn("callbackStateIn", "t.CALLBACK_STATE", sb);
whereIn("workbasketIdIn", "t.WORKBASKET_ID", sb);
whereIn("classificationKeyIn", "t.CLASSIFICATION_KEY", sb);
whereIn("classificationIdIn", "t.CLASSIFICATION_ID", sb);
whereIn("classificationCategoryIn", "CLASSIFICATION_CATEGORY", sb);
whereIn("classificationNameIn", "c.NAME", sb);
whereIn("attachmentClassificationNameIn", "ac.NAME", sb);
whereIn("ownerIn", "OWNER", sb);
whereNotIn("ownerNotIn", "OWNER", sb);
whereIn("porCompanyIn", "POR_COMPANY", sb);
whereIn("porSystemIn", "POR_SYSTEM", sb);
whereIn("porSystemInstanceIn", "POR_INSTANCE", sb);
whereIn("porTypeIn", "POR_TYPE", sb);
whereIn("porValueIn", "POR_VALUE", sb);
whereIn("parentBusinessProcessIdIn", "PARENT_BUSINESS_PROCESS_ID", sb);
whereIn("businessProcessIdIn", "BUSINESS_PROCESS_ID", sb);
whereIn("attachmentClassificationKeyIn", "a.CLASSIFICATION_KEY", sb);
commonWhereClauses("attachmentChannel", "a.CHANNEL", sb);
commonWhereClauses("attachmentClassificationKey", "a.CLASSIFICATION_KEY", sb);
commonWhereClauses("attachmentClassificationName", "ac.NAME", sb);
commonWhereClauses("attachmentReference", "a.REF_VALUE", sb);
commonWhereClauses("businessProcessId", "t.BUSINESS_PROCESS_ID", sb);
commonWhereClauses("classificationCategory", "CLASSIFICATION_CATEGORY", sb);
commonWhereClauses("classificationKey", "t.CLASSIFICATION_KEY", sb);
commonWhereClauses("classificationName", "c.NAME", sb);
commonWhereClauses("creator", "t.CREATOR", sb);
commonWhereClauses("name", "t.NAME", sb);
commonWhereClauses("owner", "t.OWNER", sb);
commonWhereClauses("parentBusinessProcessId", "t.PARENT_BUSINESS_PROCESS_ID", sb);
commonWhereClauses("porCompany", "t.POR_COMPANY", sb);
commonWhereClauses("porSystem", "t.POR_SYSTEM", sb);
commonWhereClauses("porSystemInstance", "t.POR_INSTANCE", sb);
commonWhereClauses("porType", "t.POR_TYPE", sb);
commonWhereClauses("porValue", "t.POR_VALUE", sb);
whereIn("attachmentClassificationIdIn", "a.CLASSIFICATION_ID", sb);
whereIn("attachmentChannelIn", "a.CHANNEL", sb);
whereIn("attachmentReferenceIn", "a.REF_VALUE", sb);
whereInTime("createdIn", "t.CREATED", sb);
whereInTime("claimedIn", "t.CLAIMED", sb);
whereInTime("completedIn", "t.COMPLETED", sb);
whereInTime("modifiedIn", "t.MODIFIED", sb);
whereInTime("plannedIn", "t.PLANNED", sb);
whereInTime("receivedIn", "t.RECEIVED", sb);
whereInTime("dueIn", "t.DUE", sb);
whereInTime("attachmentReceivedIn", "a.RECEIVED", sb);
whereNotIn("classificationKeyNotIn", "t.CLASSIFICATION_KEY", sb);
whereLike("externalIdLike", "t.EXTERNAL_ID", sb);
whereLike("nameLike", "t.NAME", sb);
whereLike("creatorLike", "CREATOR", sb);
whereLike("noteLike", "NOTE", sb);
whereLike("classificationKeyLike", "t.CLASSIFICATION_KEY", sb);
whereLike("classificationCategoryLike", "CLASSIFICATION_CATEGORY", sb);
whereLike("classificationNameLike", "c.NAME", sb);
whereLike("attachmentClassificationNameLike", "ac.NAME", sb);
whereLike("ownerLike", "OWNER", sb);
whereLike("porCompanyLike", "POR_COMPANY", sb);
whereLike("porSystemLike", "POR_SYSTEM", sb);
whereLike("porSystemInstanceLike", "POR_INSTANCE", sb);
whereLike("porTypeLike", "POR_TYPE", sb);
whereLike("porValueLike", "POR_VALUE", sb);
whereLike("parentBusinessProcessIdLike", "PARENT_BUSINESS_PROCESS_ID", sb);
whereLike("businessProcessIdLike", "BUSINESS_PROCESS_ID", sb);
whereLike("attachmentClassificationKeyLike", "a.CLASSIFICATION_KEY", sb);
whereLike("attachmentClassificationIdLike", "a.CLASSIFICATION_ID", sb);
whereLike("attachmentChannelLike", "a.CHANNEL", sb);
whereLike("attachmentReferenceLike", "a.REF_VALUE", sb);
whereLike("description", "DESCRIPTION", sb);
whereNotIn("attachmentClassificationIdNotIn", "a.CLASSIFICATION_ID", sb);
whereIn("callbackStateIn", "t.CALLBACK_STATE", sb);
whereNotIn("callbackStateNotIn", "t.CALLBACK_STATE", sb);
whereIn("classificationIdIn", "t.CLASSIFICATION_ID", sb);
whereNotIn("classificationIdNotIn", "t.CLASSIFICATION_ID", sb);
whereIn("externalIdIn", "t.EXTERNAL_ID", sb);
whereNotIn("externalIdNotIn", "t.EXTERNAL_ID", sb);
whereIn("priority", "t.PRIORITY", sb);
whereNotIn("priorityNotIn", "t.PRIORITY", sb);
whereIn("priority", "t.PRIORITY", sb);
whereNotIn("priorityNotIn", "t.PRIORITY", sb);
whereIn("stateIn", "t.STATE", sb);
whereNotIn("stateNotIn", "t.STATE", sb);
whereIn("taskId", "t.ID", sb);
whereNotIn("taskIdNotIn", "t.ID", sb);
whereIn("workbasketIdIn", "t.WORKBASKET_ID", sb);
whereNotIn("workbasketIdNotIn", "t.WORKBASKET_ID", sb);
whereLike("descriptionLike", "t.DESCRIPTION", sb);
whereNotLike("descriptionNotLike", "t.DESCRIPTION", sb);
whereLike("noteLike", "t.NOTE", sb);
whereNotLike("noteNotLike", "t.NOTE", sb);
whereInTime("attachmentReceivedWithin", "a.RECEIVED", sb);
whereNotInTime("attachmentReceivedNotWithin", "a.RECEIVED", sb);
whereInTime("claimedWithin", "t.CLAIMED", sb);
whereNotInTime("claimedNotWithin", "t.CLAIMED", sb);
whereInTime("completedWithin", "t.COMPLETED", sb);
whereNotInTime("completedNotWithin", "t.COMPLETED", sb);
whereInTime("createdWithin", "t.CREATED", sb);
whereNotInTime("createdNotWithin", "t.CREATED", sb);
whereInTime("dueWithin", "t.DUE", sb);
whereNotInTime("dueNotWithin", "t.DUE", sb);
whereInTime("modifiedWithin", "t.MODIFIED", sb);
whereNotInTime("modifiedNotWithin", "t.MODIFIED", sb);
whereInTime("plannedWithin", "t.PLANNED", sb);
whereNotInTime("plannedNotWithin", "t.PLANNED", sb);
whereInTime("receivedWithin", "t.RECEIVED", sb);
whereNotInTime("receivedNotWithin", "t.RECEIVED", sb);
whereCustomStatements("custom", "t.CUSTOM", 16, sb);
sb.append("<if test='isRead != null'>AND IS_READ = #{isRead}</if> ");
sb.append("<if test='isTransferred != null'>AND IS_TRANSFERRED = #{isTransferred}</if> ");
sb.append(
"<if test='workbasketKeyDomainIn != null'>AND (<foreach item='item'"
+ " collection='workbasketKeyDomainIn' separator=' OR '>(t.WORKBASKET_KEY = #{item.key}"
+ " AND t.DOMAIN = #{item.domain})</foreach>)</if> ");
return sb.toString();
sb.append(
"<if test='workbasketKeyDomainNotIn != null'>AND (<foreach item='item'"
+ " collection='workbasketKeyDomainNotIn' separator=' OR '>(t.WORKBASKET_KEY !="
+ " #{item.key} OR t.DOMAIN != #{item.domain})</foreach>)</if> ");
sb.append(
"<if test='wildcardSearchValueLike != null and wildcardSearchFieldIn != null'>AND ("
+ "<foreach item='item' collection='wildcardSearchFieldIn' separator=' OR '>"
+ "UPPER(t.${item}) "
+ "LIKE #{wildcardSearchValueLike}"
+ "</foreach>)"
+ "</if> ");
sb.append(commonTaskObjectReferenceWhereStatement());
return sb;
}
}

13
lib/taskana-core/src/main/java/pro/taskana/task/internal/builder/TaskBuilder.java
View File

@ -22,6 +22,7 @@ import pro.taskana.task.api.exceptions.TaskNotFoundException;
import pro.taskana.task.api.models.Attachment;
import pro.taskana.task.api.models.ObjectReference;
import pro.taskana.task.api.models.Task;
import pro.taskana.task.api.models.TaskSummary;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
import pro.taskana.workbasket.api.models.WorkbasketSummary;
@ -213,4 +214,16 @@ public class TaskBuilder {
return Subject.doAs(subject, performBuildAndStore);
}
public TaskSummary buildAndStoreAsSummary(TaskService taskService)
throws TaskAlreadyExistException, InvalidArgumentException, TaskNotFoundException,
WorkbasketNotFoundException, ClassificationNotFoundException, NotAuthorizedException,
AttachmentPersistenceException {
return buildAndStore(taskService).asSummary();
}
public TaskSummary buildAndStoreAsSummary(TaskService taskService, String userId)
throws PrivilegedActionException {
return buildAndStore(taskService, userId).asSummary();
}
}

4
lib/taskana-core/src/main/java/pro/taskana/task/internal/models/TaskSummaryImpl.java
View File

@ -22,13 +22,13 @@ public class TaskSummaryImpl implements TaskSummary {
protected String id;
protected String externalId;
protected Instant received;
protected Instant created;
protected Instant claimed;
protected Instant completed;
protected Instant modified;
protected Instant planned;
protected Instant received;
protected Instant due;
protected Instant completed;
protected String name;
protected String creator;
protected String note;

12
lib/taskana-core/src/main/java/pro/taskana/workbasket/internal/builder/WorkbasketBuilder.java
View File

@ -15,6 +15,7 @@ import pro.taskana.workbasket.api.WorkbasketType;
import pro.taskana.workbasket.api.exceptions.WorkbasketAlreadyExistException;
import pro.taskana.workbasket.api.exceptions.WorkbasketNotFoundException;
import pro.taskana.workbasket.api.models.Workbasket;
import pro.taskana.workbasket.api.models.WorkbasketSummary;
public class WorkbasketBuilder {
@ -127,4 +128,15 @@ public class WorkbasketBuilder {
return Subject.doAs(subject, performBuildAndStore);
}
public WorkbasketSummary buildAndStoreAsSummary(WorkbasketService workbasketService)
throws InvalidArgumentException, WorkbasketAlreadyExistException, WorkbasketNotFoundException,
DomainNotFoundException, NotAuthorizedException {
return buildAndStore(workbasketService).asSummary();
}
public WorkbasketSummary buildAndStoreAsSummary(
WorkbasketService workbasketService, String userId) throws PrivilegedActionException {
return buildAndStore(workbasketService, userId).asSummary();
}
}

13
lib/taskana-core/src/test/java/acceptance/ArchitectureTest.java
View File

@ -341,12 +341,23 @@ class ArchitectureTest {
private DescribedPredicate<JavaClass> areNestedTaskanaIntegrationTestClasses() {
return new DescribedPredicate<JavaClass>("are nested TaskanaIntegrationTest classes") {
@Override
public boolean apply(JavaClass input) {
Optional<JavaClass> enclosingClass = input.getEnclosingClass();
return input.isAnnotatedWith(Nested.class)
&& enclosingClass.isPresent()
&& enclosingClass.get().isAnnotatedWith(TaskanaIntegrationTest.class);
&& isTaskanaIntegrationTest(enclosingClass.get());
}
private boolean isTaskanaIntegrationTest(JavaClass input) {
Optional<JavaClass> enclosingClass = input.getEnclosingClass();
if (enclosingClass.isPresent()) {
return input.isAnnotatedWith(Nested.class)
&& isTaskanaIntegrationTest(enclosingClass.get());
} else {
return input.isAnnotatedWith(TaskanaIntegrationTest.class);
}
}
};
}

24
lib/taskana-core/src/test/java/acceptance/builder/ClassificationBuilderTest.java
View File

@ -19,8 +19,10 @@ import testapi.TaskanaIntegrationTest;
import pro.taskana.classification.api.ClassificationCustomField;
import pro.taskana.classification.api.ClassificationService;
import pro.taskana.classification.api.models.Classification;
import pro.taskana.classification.api.models.ClassificationSummary;
import pro.taskana.classification.internal.builder.ClassificationBuilder;
import pro.taskana.classification.internal.models.ClassificationImpl;
import pro.taskana.classification.internal.models.ClassificationSummaryImpl;
import pro.taskana.common.internal.util.Quadruple;
import pro.taskana.common.test.security.WithAccessId;
@ -129,6 +131,28 @@ class ClassificationBuilderTest {
.doesNotThrowAnyException();
}
@WithAccessId(user = "businessadmin")
@Test
void should_ReturnClassificationImpl_When_BuildingClassification() throws Exception {
Classification classification =
newClassification().key("key6_A").domain("DOMAIN_A").buildAndStore(classificationService);
assertThat(classification.getClass()).isEqualTo(ClassificationImpl.class);
}
@WithAccessId(user = "businessadmin")
@Test
void should_ReturnClassificationSummaryImpl_When_BuildingClassificationAsSummary()
throws Exception {
ClassificationSummary classificationSummary =
newClassification()
.key("key7_A")
.domain("DOMAIN_A")
.buildAndStoreAsSummary(classificationService);
assertThat(classificationSummary.getClass()).isEqualTo(ClassificationSummaryImpl.class);
}
@WithAccessId(user = "businessadmin")
@TestFactory
Stream<DynamicContainer> should_PersistClassification_When_CreatingEntityWithInvalidApiValues() {

3
lib/taskana-core/src/test/java/acceptance/builder/TaskAttachmentBuilderTest.java
View File

@ -30,8 +30,7 @@ class TaskAttachmentBuilderTest {
ClassificationBuilder.newClassification()
.domain("DOMAIN_A")
.key("key")
.buildAndStore(classificationService, "businessadmin")
.asSummary();
.buildAndStoreAsSummary(classificationService, "businessadmin");
ObjectReference objectReference = DefaultTestEntities.defaultTestObjectReference().build();
final Attachment attachment =

34
lib/taskana-core/src/test/java/acceptance/builder/TaskBuilderTest.java
View File

@ -34,9 +34,11 @@ import pro.taskana.task.api.TaskService;
import pro.taskana.task.api.TaskState;
import pro.taskana.task.api.models.Attachment;
import pro.taskana.task.api.models.Task;
import pro.taskana.task.api.models.TaskSummary;
import pro.taskana.task.internal.builder.TaskAttachmentBuilder;
import pro.taskana.task.internal.builder.TaskBuilder;
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.models.WorkbasketSummary;
@ -57,14 +59,12 @@ class TaskBuilderTest {
defaultTestWorkbasket()
.owner("user-1-1")
.key("key0_D")
.buildAndStore(workbasketService)
.asSummary();
.buildAndStoreAsSummary(workbasketService);
classificationSummary =
newClassification()
.key("key0_D")
.domain("DOMAIN_A")
.buildAndStore(classificationService)
.asSummary();
.buildAndStoreAsSummary(classificationService);
newWorkbasketAccessItem()
.workbasketId(workbasketSummary.getId())
.accessId("user-1-1")
@ -219,6 +219,32 @@ class TaskBuilderTest {
.doesNotThrowAnyException();
}
@WithAccessId(user = "user-1-1")
@Test
void should_ReturnTaskImpl_When_BuildingTask() throws Exception {
Task task =
newTask()
.workbasketSummary(workbasketSummary)
.classificationSummary(classificationSummary)
.primaryObjRef(defaultTestObjectReference().build())
.buildAndStore(taskService);
assertThat(task.getClass()).isEqualTo(TaskImpl.class);
}
@WithAccessId(user = "user-1-1")
@Test
void should_ReturnTaskSummaryImpl_When_BuildingTaskAsSummary() throws Exception {
TaskSummary taskSummary =
newTask()
.workbasketSummary(workbasketSummary)
.classificationSummary(classificationSummary)
.primaryObjRef(defaultTestObjectReference().build())
.buildAndStoreAsSummary(taskService);
assertThat(taskSummary.getClass()).isEqualTo(TaskSummaryImpl.class);
}
@WithAccessId(user = "user-1-1")
@TestFactory
Stream<DynamicContainer> should_PersistClassification_When_CreatingEntityWithInvalidApiValues() {

30
lib/taskana-core/src/test/java/acceptance/builder/WorkbasketBuilderTest.java
View File

@ -24,8 +24,10 @@ import pro.taskana.workbasket.api.WorkbasketCustomField;
import pro.taskana.workbasket.api.WorkbasketService;
import pro.taskana.workbasket.api.WorkbasketType;
import pro.taskana.workbasket.api.models.Workbasket;
import pro.taskana.workbasket.api.models.WorkbasketSummary;
import pro.taskana.workbasket.internal.builder.WorkbasketBuilder;
import pro.taskana.workbasket.internal.models.WorkbasketImpl;
import pro.taskana.workbasket.internal.models.WorkbasketSummaryImpl;
@TaskanaIntegrationTest
class WorkbasketBuilderTest {
@ -131,6 +133,34 @@ class WorkbasketBuilderTest {
.doesNotThrowAnyException();
}
@WithAccessId(user = "businessadmin")
@Test
void should_ReturnWorkbasketImpl_When_BuildingWorkbasket() throws Exception {
Workbasket workbasket =
newWorkbasket()
.key("key6_G")
.domain("DOMAIN_A")
.name("Megabasket")
.type(WorkbasketType.GROUP)
.buildAndStore(workbasketService);
assertThat(workbasket.getClass()).isEqualTo(WorkbasketImpl.class);
}
@WithAccessId(user = "businessadmin")
@Test
void should_ReturnWorkbasketSummaryImpl_When_BuildingWorkbasketAsSummary() throws Exception {
WorkbasketSummary workbasketSummary =
newWorkbasket()
.key("key7_G")
.domain("DOMAIN_A")
.name("Megabasket")
.type(WorkbasketType.GROUP)
.buildAndStoreAsSummary(workbasketService);
assertThat(workbasketSummary.getClass()).isEqualTo(WorkbasketSummaryImpl.class);
}
@WithAccessId(user = "businessadmin")
@TestFactory
Stream<DynamicContainer> should_PersistWorkbasket_When_CreatingEntityWithInvalidApiValues() {

9
lib/taskana-core/src/test/java/acceptance/jobs/helper/TaskUpdatePriorityWorkerAccTest.java
View File

@ -53,10 +53,9 @@ class TaskUpdatePriorityWorkerAccTest {
throws Exception {
classificationSummary =
DefaultTestEntities.defaultTestClassification()
.buildAndStore(classificationService)
.asSummary();
.buildAndStoreAsSummary(classificationService);
workbasketSummary =
DefaultTestEntities.defaultTestWorkbasket().buildAndStore(workbasketService).asSummary();
DefaultTestEntities.defaultTestWorkbasket().buildAndStoreAsSummary(workbasketService);
// Currently, we have a bug: TSK-1736
// Because of that we need at least one WorkbasketAccessItem with the correct permissions.
@ -73,8 +72,8 @@ class TaskUpdatePriorityWorkerAccTest {
.workbasketSummary(workbasketSummary)
.primaryObjRef(DefaultTestEntities.defaultTestObjectReference().build());
task1 = taskBuilder.buildAndStore(taskService).asSummary();
task2 = taskBuilder.buildAndStore(taskService).asSummary();
task1 = taskBuilder.buildAndStoreAsSummary(taskService);
task2 = taskBuilder.buildAndStoreAsSummary(taskService);
completedTask = taskBuilder.state(TaskState.COMPLETED).buildAndStore(taskService);
worker = new TaskUpdatePriorityWorker(taskanaEngine);
}

61
lib/taskana-core/src/test/java/acceptance/task/QueryTasksAccTest.java
View File

@ -110,25 +110,6 @@ class QueryTasksAccTest extends AbstractAccTest {
assertThat(results).hasSize(2);
}
@WithAccessId(user = "admin")
@Test
void testQueryForParentBusinessProcessId() {
List<TaskSummary> results =
TASK_SERVICE.createTaskQuery().parentBusinessProcessIdLike("%PBPI%", "doc%3%").list();
assertThat(results).hasSize(33);
for (TaskSummary taskSummary : results) {
assertThat(taskSummary.getExternalId()).isNotNull();
}
String[] parentIds =
results.stream().map(TaskSummary::getParentBusinessProcessId).toArray(String[]::new);
List<TaskSummary> result2 =
TASK_SERVICE.createTaskQuery().parentBusinessProcessIdIn(parentIds).list();
assertThat(result2).hasSize(33);
}
@WithAccessId(user = "admin")
@Test
void testQueryForName() {
@ -193,24 +174,6 @@ class QueryTasksAccTest extends AbstractAccTest {
assertThat(results.get(0).getAttachmentSummaries().get(0)).isNotNull();
}
@WithAccessId(user = "admin")
@Test
void testQueryForExternalId() {
List<TaskSummary> results =
TASK_SERVICE
.createTaskQuery()
.externalIdIn(
"ETI:000000000000000000000000000000000000",
"ETI:000000000000000000000000000000000001")
.list();
assertThat(results).hasSize(2);
long countAllExternalIds = TASK_SERVICE.createTaskQuery().externalIdLike("ETI:%").count();
long countAllIds = TASK_SERVICE.createTaskQuery().count();
assertThat(countAllExternalIds).isEqualTo(countAllIds);
}
@WithAccessId(user = "admin")
@TestFactory
Stream<DynamicTest> should_ReturnCorrectResults_When_QueryingForCustomXStatements() {
@ -537,13 +500,6 @@ class QueryTasksAccTest extends AbstractAccTest {
assertThat(results).hasSize(9);
}
@WithAccessId(user = "admin")
@Test
void testQueryForBusinessProcessIdLike() {
List<TaskSummary> results = TASK_SERVICE.createTaskQuery().businessProcessIdLike("pI_%").list();
assertThat(results).hasSize(80);
}
@WithAccessId(user = "admin")
@Test
void testQueryForAttachmentClassificationKeyIn() {
@ -906,21 +862,4 @@ class QueryTasksAccTest extends AbstractAccTest {
List<TaskSummary> result2 = TASK_SERVICE.createTaskQuery().idIn(ids).list();
assertThat(result2).hasSize(10);
}
@WithAccessId(user = "admin")
@Test
void testQueryForExternalIdLike() {
List<TaskSummary> results =
TASK_SERVICE
.createTaskQuery()
.externalIdLike("ETI:00000000000000000000000000000000001%")
.list();
assertThat(results).hasSize(10);
String[] ids = results.stream().map(TaskSummary::getId).toArray(String[]::new);
List<TaskSummary> result2 = TASK_SERVICE.createTaskQuery().idIn(ids).list();
assertThat(result2).hasSize(10);
}
}

20
lib/taskana-core/src/test/java/acceptance/task/QueryTasksByWildcardSearchAccTest.java
View File

@ -56,26 +56,6 @@ class QueryTasksByWildcardSearchAccTest extends AbstractAccTest {
assertThat(foundTasks).isEqualTo(4);
}
@WithAccessId(user = "admin")
@Test
void should_ReturnAllTasks_For_ProvidedSearchValueAndAdditionalParameters() {
WildcardSearchField[] wildcards = {
WildcardSearchField.CUSTOM_3, WildcardSearchField.CUSTOM_4, WildcardSearchField.NAME
};
List<TaskSummary> foundTasks =
TASK_SERVICE
.createTaskQuery()
.wildcardSearchFieldsIn(wildcards)
.wildcardSearchValueLike("%99%")
.ownerIn("user-1-1")
.businessProcessIdLike("%PI2%")
.orderByName(SortDirection.ASCENDING)
.list();
assertThat(foundTasks).hasSize(1);
}
@WithAccessId(user = "admin")
@Test
void should_ReturnAllTasksCaseInsensitive_When_PerformingWildcardQuery() {

12
lib/taskana-core/src/test/java/acceptance/task/QueryTasksListValuesAccTest.java
View File

@ -97,18 +97,6 @@ class QueryTasksListValuesAccTest extends AbstractAccTest {
assertThat(columnValueList).hasSize(7);
}
@WithAccessId(user = "admin")
@Test
void should_ReturnAllExternalIds_When_ListValuesForExternalIdsIsInvoked() {
List<String> resultValues =
TASK_SERVICE
.createTaskQuery()
.externalIdLike("ETI:000000000000000000000000000000%")
.listValues(TaskQueryColumnName.EXTERNAL_ID, DESCENDING);
assertThat(resultValues).hasSize(74);
}
@WithAccessId(user = "teamlead-1")
@Test
void should_ReturnPorTypes_When_QueryingForListOfPorTypesForWorkbasket() {

2515
lib/taskana-core/src/test/java/acceptance/task/TaskQueryImplAccTest.java Normal file
View File

File diff suppressed because it is too large Load Diff

5
lib/taskana-core/src/test/java/acceptance/taskpreprocessing/CreateTaskPreprocessingAccTest.java
View File

@ -39,11 +39,10 @@ class CreateTaskPreprocessingAccTest {
throws Exception {
classificationSummary =
DefaultTestEntities.defaultTestClassification()
.buildAndStore(classificationService)
.asSummary();
.buildAndStoreAsSummary(classificationService);
workbasketSummary =
DefaultTestEntities.defaultTestWorkbasket().buildAndStore(workbasketService).asSummary();
DefaultTestEntities.defaultTestWorkbasket().buildAndStoreAsSummary(workbasketService);
WorkbasketAccessItemBuilder.newWorkbasketAccessItem()
.accessId("user-1-1")

6
lib/taskana-core/src/test/java/acceptance/taskrouting/TaskRoutingAccTest.java
View File

@ -42,13 +42,11 @@ class TaskRoutingAccTest {
throws Exception {
classificationSummary =
DefaultTestEntities.defaultTestClassification()
.buildAndStore(classificationService)
.asSummary();
.buildAndStoreAsSummary(classificationService);
domainAWorkbasket =
DefaultTestEntities.defaultTestWorkbasket()
.key("DOMAIN_A_WORKBASKET")
.buildAndStore(workbasketService)
.asSummary();
.buildAndStoreAsSummary(workbasketService);
WorkbasketAccessItemBuilder.newWorkbasketAccessItem()
.workbasketId(domainAWorkbasket.getId())

16
lib/taskana-core/src/test/java/testapi/util/ExtensionCommunicator.java
View File

@ -27,17 +27,25 @@ public class ExtensionCommunicator {
return context.getStore(determineNamespace(testClass));
}
public static Class<?> getTopLevelClass(Class<?> testClazz) {
Class<?> parent = testClazz;
while (parent.getEnclosingClass() != null) {
parent = parent.getEnclosingClass();
}
return parent;
}
private static Namespace determineNamespace(Class<?> testClass) {
if (isTopLevelClass(testClass)) {
return Namespace.create(testClass);
} else if (isAnnotated(testClass, CleanTaskanaContext.class)) {
return Namespace.create(testClass.getEnclosingClass(), testClass, CleanTaskanaContext.class);
return Namespace.create(getTopLevelClass(testClass), testClass, CleanTaskanaContext.class);
} else if (isAnnotated(testClass, WithServiceProvider.class)) {
return Namespace.create(testClass.getEnclosingClass(), testClass, WithServiceProvider.class);
return Namespace.create(getTopLevelClass(testClass), testClass, WithServiceProvider.class);
} else if (TaskanaEngineConfigurationModifier.class.isAssignableFrom(testClass)) {
return Namespace.create(
testClass.getEnclosingClass(), testClass, TaskanaEngineConfigurationModifier.class);
getTopLevelClass(testClass), testClass, TaskanaEngineConfigurationModifier.class);
}
return Namespace.create(testClass.getEnclosingClass());
return Namespace.create(getTopLevelClass(testClass));
}
}

2808
rest/taskana-rest-spring/src/main/java/pro/taskana/task/rest/TaskQueryFilterParameter.java
View File

File diff suppressed because it is too large Load Diff