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

TSK-1697: Fixed ambiguous domain in listValues query when joining with classifications

This commit is contained in:
Holger Hagen 2021-08-10 15:46:58 +02:00 committed by holgerhagen
parent 6d11ae371d
commit a4ab94bb04
3 changed files with 142 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -313,7 +313,7 @@ public class TaskQuerySqlProvider {
whereIn("creatorIn", "CREATOR", sb);
whereIn("stateIn", "STATE", sb);
whereIn("callbackStateIn", "t.CALLBACK_STATE", sb);
whereIn("workbasketIdIn", "WORKBASKET_ID", sb);
whereIn("workbasketIdIn", "t.WORKBASKET_ID", sb);
whereIn("classificationKeyIn", "t.CLASSIFICATION_KEY", sb);
whereIn("classificationIdIn", "t.CLASSIFICATION_ID", sb);
whereIn("classificationCategoryIn", "CLASSIFICATION_CATEGORY", sb);
@ -366,8 +366,8 @@ public class TaskQuerySqlProvider {
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 '>(WORKBASKET_KEY = #{item.key}"
+ " AND DOMAIN = #{item.domain})</foreach>)</if> ");
+ " collection='workbasketKeyDomainIn' separator=' OR '>(t.WORKBASKET_KEY = #{item.key}"
+ " AND t.DOMAIN = #{item.domain})</foreach>)</if> ");
return sb.toString();
}

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

@ -9,12 +9,6 @@ import static org.mockito.ArgumentMatchers.eq;
import static pro.taskana.common.api.BaseQuery.SortDirection.ASCENDING;
import static pro.taskana.common.api.BaseQuery.SortDirection.DESCENDING;
import static pro.taskana.task.api.TaskCustomField.CUSTOM_7;
import static pro.taskana.task.api.TaskQueryColumnName.A_CHANNEL;
import static pro.taskana.task.api.TaskQueryColumnName.A_CLASSIFICATION_ID;
import static pro.taskana.task.api.TaskQueryColumnName.A_REF_VALUE;
import static pro.taskana.task.api.TaskQueryColumnName.CLASSIFICATION_KEY;
import static pro.taskana.task.api.TaskQueryColumnName.OWNER;
import static pro.taskana.task.api.TaskQueryColumnName.STATE;
import acceptance.AbstractAccTest;
import acceptance.TaskTestMapper;
@ -29,7 +23,6 @@ import java.util.Objects;
import java.util.stream.Stream;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSession;
import org.assertj.core.api.SoftAssertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.Test;
@ -48,7 +41,6 @@ import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskCustomField;
import pro.taskana.task.api.TaskQuery;
import pro.taskana.task.api.TaskQueryColumnName;
import pro.taskana.task.api.models.Attachment;
import pro.taskana.task.api.models.AttachmentSummary;
import pro.taskana.task.api.models.ObjectReference;
@ -72,68 +64,6 @@ class QueryTasksAccTest extends AbstractAccTest {
resetDb(false);
}
@WithAccessId(user = "admin")
@Test
void testQueryTaskValuesForEveryColumn() {
SoftAssertions softly = new SoftAssertions();
Arrays.stream(TaskQueryColumnName.values())
.forEach(
columnName ->
softly
.assertThatCode(
() -> TASK_SERVICE.createTaskQuery().listValues(columnName, ASCENDING))
.describedAs("Column is not working " + columnName)
.doesNotThrowAnyException());
softly.assertAll();
}
@WithAccessId(user = "admin")
@Test
void testQueryTaskValuesForColumnName() {
List<String> columnValueList =
TASK_SERVICE
.createTaskQuery()
.ownerLike("%user%")
.orderByOwner(DESCENDING)
.listValues(OWNER, null);
assertThat(columnValueList).hasSize(3);
columnValueList = TASK_SERVICE.createTaskQuery().listValues(STATE, null);
assertThat(columnValueList).hasSize(5);
}
@WithAccessId(user = "admin")
@Test
void testQueryTaskValuesForColumnNameOnAttachments() {
List<String> columnValueList =
TASK_SERVICE
.createTaskQuery()
.attachmentReferenceValueIn("val4")
.listValues(A_CHANNEL, null);
assertThat(columnValueList).hasSize(2);
columnValueList =
TASK_SERVICE
.createTaskQuery()
.attachmentReferenceValueLike("%")
.listValues(A_REF_VALUE, null);
assertThat(columnValueList).hasSize(6);
columnValueList =
TASK_SERVICE
.createTaskQuery()
.orderByAttachmentClassificationId(DESCENDING)
.listValues(A_CLASSIFICATION_ID, null);
assertThat(columnValueList).hasSize(11);
columnValueList =
TASK_SERVICE
.createTaskQuery()
.orderByClassificationKey(DESCENDING)
.listValues(CLASSIFICATION_KEY, null);
assertThat(columnValueList).hasSize(7);
}
@WithAccessId(user = "admin")
@Test
void should_SplitTaskListIntoChunksOf32000_When_AugmentingTasksAfterTaskQuery() {
@ -274,13 +204,6 @@ class QueryTasksAccTest extends AbstractAccTest {
.list();
assertThat(results).hasSize(2);
List<String> resultValues =
TASK_SERVICE
.createTaskQuery()
.externalIdLike("ETI:000000000000000000000000000000%")
.listValues(TaskQueryColumnName.EXTERNAL_ID, DESCENDING);
assertThat(resultValues).hasSize(74);
long countAllExternalIds = TASK_SERVICE.createTaskQuery().externalIdLike("ETI:%").count();
long countAllIds = TASK_SERVICE.createTaskQuery().count();
assertThat(countAllExternalIds).isEqualTo(countAllIds);

139
lib/taskana-core/src/test/java/acceptance/task/QueryTasksListValuesAccTest.java Normal file
View File

@ -0,0 +1,139 @@
package acceptance.task;
import static org.assertj.core.api.Assertions.assertThat;
import static pro.taskana.common.api.BaseQuery.SortDirection.ASCENDING;
import static pro.taskana.common.api.BaseQuery.SortDirection.DESCENDING;
import static pro.taskana.task.api.TaskQueryColumnName.A_CHANNEL;
import static pro.taskana.task.api.TaskQueryColumnName.A_CLASSIFICATION_ID;
import static pro.taskana.task.api.TaskQueryColumnName.A_REF_VALUE;
import static pro.taskana.task.api.TaskQueryColumnName.CLASSIFICATION_KEY;
import static pro.taskana.task.api.TaskQueryColumnName.OWNER;
import static pro.taskana.task.api.TaskQueryColumnName.STATE;
import acceptance.AbstractAccTest;
import java.util.Arrays;
import java.util.List;
import org.assertj.core.api.SoftAssertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import pro.taskana.common.api.BaseQuery.SortDirection;
import pro.taskana.common.api.KeyDomain;
import pro.taskana.common.test.security.JaasExtension;
import pro.taskana.common.test.security.WithAccessId;
import pro.taskana.task.api.TaskQueryColumnName;
import pro.taskana.task.internal.TaskServiceImpl;
/** Acceptance test for listing the column values within a workbasket. */
@ExtendWith(JaasExtension.class)
class QueryTasksListValuesAccTest extends AbstractAccTest {
private static final TaskServiceImpl TASK_SERVICE =
(TaskServiceImpl) taskanaEngine.getTaskService();
@WithAccessId(user = "admin")
@Test
void should_ReturnColumnValues_When_ListValuesForColumnIsInvoked() {
SoftAssertions softly = new SoftAssertions();
Arrays.stream(TaskQueryColumnName.values())
.forEach(
columnName ->
softly
.assertThatCode(
() -> TASK_SERVICE.createTaskQuery().listValues(columnName, ASCENDING))
.describedAs("Column is not working " + columnName)
.doesNotThrowAnyException());
softly.assertAll();
}
@WithAccessId(user = "admin")
@Test
void should_ReturnOwnerValues_When_ListValuesForOwnerIsInvoked() {
List<String> columnValueList =
TASK_SERVICE
.createTaskQuery()
.ownerLike("%user%")
.orderByOwner(DESCENDING)
.listValues(OWNER, null);
assertThat(columnValueList).hasSize(3);
}
@WithAccessId(user = "admin")
@Test
void should_ReturnStateValues_When_ListValuesForStateIsInvoked() {
List<String> columnValueList = TASK_SERVICE.createTaskQuery().listValues(STATE, null);
assertThat(columnValueList).hasSize(5);
}
@WithAccessId(user = "admin")
@Test
void should_ReturnAttachmentColumnValues_When_ListValuesForAttachmentColumnsIsInvoked() {
List<String> columnValueList =
TASK_SERVICE
.createTaskQuery()
.attachmentReferenceValueIn("val4")
.listValues(A_CHANNEL, null);
assertThat(columnValueList).hasSize(2);
columnValueList =
TASK_SERVICE
.createTaskQuery()
.attachmentReferenceValueLike("%")
.listValues(A_REF_VALUE, null);
assertThat(columnValueList).hasSize(6);
columnValueList =
TASK_SERVICE
.createTaskQuery()
.orderByAttachmentClassificationId(DESCENDING)
.listValues(A_CLASSIFICATION_ID, null);
assertThat(columnValueList).hasSize(11);
columnValueList =
TASK_SERVICE
.createTaskQuery()
.orderByClassificationKey(DESCENDING)
.listValues(CLASSIFICATION_KEY, null);
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() {
KeyDomain keyDomain = new KeyDomain("GPK_KSC", "DOMAIN_A");
List<String> porTypes =
TASK_SERVICE
.createTaskQuery()
.workbasketKeyDomainIn(keyDomain)
.primaryObjectReferenceCompanyIn("00", "11")
.listValues(TaskQueryColumnName.POR_TYPE, SortDirection.ASCENDING);
assertThat(porTypes).containsExactly("SDNR", "VNR");
}
@WithAccessId(user = "teamlead-1")
@Test
void should_ReturnAttachmentClassificationNames_When_QueryingForListNames() {
KeyDomain keyDomain = new KeyDomain("GPK_KSC", "DOMAIN_A");
List<String> attachmentClassificationNames =
TASK_SERVICE
.createTaskQuery()
.workbasketKeyDomainIn(keyDomain)
.listValues(TaskQueryColumnName.A_CLASSIFICATION_NAME, SortDirection.ASCENDING);
assertThat(attachmentClassificationNames)
// PostgreSQL treats null differently while sorting
.containsExactlyInAnyOrder(
null, "Beratungsprotokoll", "Dynamikänderung", "Widerruf", "Zustimmungserklärung");
}
}