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

TSK-400: added configuration of classification types.

This commit is contained in:
Holger Hagen 2018-03-29 15:12:36 +02:00 committed by Mustapha Zorgati
parent 906aa8f386
commit df4638f2fc
18 changed files with 196 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
lib/taskana-core/src/main/java/pro/taskana/ClassificationService.java
View File

@ -5,6 +5,7 @@ import pro.taskana.exceptions.ClassificationInUseException;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.ConcurrencyException;
import pro.taskana.exceptions.DomainNotFoundException;
import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.NotAuthorizedException;
/**
@ -73,7 +74,7 @@ public interface ClassificationService {
*/
Classification createClassification(Classification classification)
throws ClassificationAlreadyExistException, NotAuthorizedException, ClassificationNotFoundException,
DomainNotFoundException;
DomainNotFoundException, InvalidArgumentException;
/**
* Updates a Classification.
@ -89,7 +90,7 @@ public interface ClassificationService {
* when the Classification was modified meanwhile and is not latest anymore.
*/
Classification updateClassification(Classification classification)
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException;
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException, InvalidArgumentException;
/**
* This method provides a query builder for quering the database.

24
lib/taskana-core/src/main/java/pro/taskana/configuration/TaskanaEngineConfiguration.java
View File

@ -45,6 +45,7 @@ public class TaskanaEngineConfiguration {
private static final String TASKANA_PROPERTIES = "/taskana.properties";
private static final String TASKANA_ROLES_SEPARATOR = "|";
private static final String TASKANA_DOMAINS_PROPERTY = "taskana.domains";
private static final String TASKANA_CLASSIFICATION_TYPES_PROPERTY = "taskana.classification.types";
// Taskana properties file
protected String propertiesFileName = TASKANA_PROPERTIES;
@ -69,6 +70,9 @@ public class TaskanaEngineConfiguration {
// List of configured domain names
protected List<String> domains = new ArrayList<String>();
// List of configured classification types
protected List<String> classificationTypes = new ArrayList<String>();
public TaskanaEngineConfiguration(DataSource dataSource, boolean useManagedTransactions)
throws SQLException {
this(dataSource, useManagedTransactions, true);
@ -110,6 +114,7 @@ public class TaskanaEngineConfiguration {
Properties props = readPropertiesFromFile(propertiesFile);
initTaskanaRoles(props, rolesSeparator);
initDomains(props);
initClassificationTypes(props);
}
private void initDomains(Properties props) {
@ -123,6 +128,17 @@ public class TaskanaEngineConfiguration {
LOGGER.debug("Configured domains: {}", domains);
}
private void initClassificationTypes(Properties props) {
String classificationTypesNames = props.getProperty(TASKANA_CLASSIFICATION_TYPES_PROPERTY);
if (classificationTypesNames != null && !classificationTypesNames.isEmpty()) {
StringTokenizer st = new StringTokenizer(classificationTypesNames, ",");
while (st.hasMoreTokens()) {
classificationTypes.add(st.nextToken().trim().toUpperCase());
}
}
LOGGER.debug("Configured domains: {}", domains);
}
private void initTaskanaRoles(Properties props, String rolesSeparator) {
List<String> validPropertyNames = Arrays.stream(TaskanaRole.values())
.map(TaskanaRole::getPropertyName)
@ -284,6 +300,14 @@ public class TaskanaEngineConfiguration {
this.domains = domains;
}
public List<String> getClassificationTypes() {
return classificationTypes;
}
public void setClassificationTypes(List<String> classificationTypes) {
this.classificationTypes = classificationTypes;
}
/**
* Helper method to determine whether all access ids (user Id and group ids) should be used in lower case.
*

6
lib/taskana-core/src/main/java/pro/taskana/impl/ClassificationImpl.java
View File

@ -1,6 +1,5 @@
package pro.taskana.impl;
import java.time.Duration;
import java.time.Instant;
import pro.taskana.Classification;
@ -158,11 +157,6 @@ public class ClassificationImpl implements Classification {
@Override
public void setServiceLevel(String serviceLevel) {
try {
Duration.parse(serviceLevel);
} catch (Exception e) {
throw new IllegalArgumentException("Invalid duration. Please use the format defined by ISO 8601");
}
this.serviceLevel = serviceLevel;
}

17
lib/taskana-core/src/main/java/pro/taskana/impl/ClassificationServiceImpl.java
View File

@ -21,6 +21,7 @@ import pro.taskana.exceptions.ClassificationInUseException;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.ConcurrencyException;
import pro.taskana.exceptions.DomainNotFoundException;
import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.exceptions.NotAuthorizedToQueryWorkbasketException;
import pro.taskana.exceptions.SystemException;
@ -52,7 +53,7 @@ public class ClassificationServiceImpl implements ClassificationService {
@Override
public Classification createClassification(Classification classification)
throws ClassificationAlreadyExistException, NotAuthorizedException, ClassificationNotFoundException,
DomainNotFoundException {
DomainNotFoundException, InvalidArgumentException {
LOGGER.debug("entry to createClassification(classification = {})", classification);
taskanaEngine.checkRoleMembership(TaskanaRole.BUSINESS_ADMIN, TaskanaRole.ADMIN);
if (!taskanaEngine.domainExists(classification.getDomain()) && !"".equals(classification.getDomain())) {
@ -125,7 +126,7 @@ public class ClassificationServiceImpl implements ClassificationService {
@Override
public Classification updateClassification(Classification classification)
throws NotAuthorizedException, ConcurrencyException, ClassificationNotFoundException {
throws NotAuthorizedException, ConcurrencyException, ClassificationNotFoundException, InvalidArgumentException {
LOGGER.debug("entry to updateClassification(Classification = {})", classification);
taskanaEngine.checkRoleMembership(TaskanaRole.BUSINESS_ADMIN, TaskanaRole.ADMIN);
ClassificationImpl classificationImpl = null;
@ -199,7 +200,7 @@ public class ClassificationServiceImpl implements ClassificationService {
*
* @param classification
*/
private void initDefaultClassificationValues(ClassificationImpl classification) throws IllegalStateException {
private void initDefaultClassificationValues(ClassificationImpl classification) throws InvalidArgumentException {
Instant now = Instant.now();
if (classification.getId() == null) {
classification.setId(IdGenerator.generateWithPrefix(ID_PREFIX_CLASSIFICATION));
@ -221,18 +222,24 @@ public class ClassificationServiceImpl implements ClassificationService {
try {
Duration.parse(classification.getServiceLevel());
} catch (Exception e) {
throw new IllegalArgumentException("Invalid duration. Please use the format defined by ISO 8601");
throw new InvalidArgumentException("Invalid duration. Please use the format defined by ISO 8601");
}
}
if (classification.getKey() == null) {
throw new IllegalStateException("Classification must contain a key");
throw new InvalidArgumentException("Classification must contain a key");
}
if (classification.getParentId() == null) {
classification.setParentId("");
}
if (classification.getType() != null
&& !taskanaEngine.getConfiguration().getClassificationTypes().contains(classification.getType())) {
throw new InvalidArgumentException("Given classification type " + classification.getType()
+ " is not valid according to the configuration.");
}
if (classification.getDomain().isEmpty()) {
classification.setIsValidInDomain(false);
}

28
lib/taskana-core/src/test/java/acceptance/classification/CreateClassificationAccTest.java
View File

@ -13,6 +13,7 @@ import pro.taskana.ClassificationService;
import pro.taskana.exceptions.ClassificationAlreadyExistException;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.DomainNotFoundException;
import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.security.JAASRunner;
import pro.taskana.security.WithAccessId;
@ -36,7 +37,7 @@ public class CreateClassificationAccTest extends AbstractAccTest {
@Test
public void testCreateRootClassification()
throws ClassificationAlreadyExistException, ClassificationNotFoundException, NotAuthorizedException,
DomainNotFoundException {
DomainNotFoundException, InvalidArgumentException {
long amountOfClassificationsBefore = classificationService.createClassificationQuery().count();
Classification classification = classificationService.newClassification("Key0", "", "TASK");
classification.setIsValidInDomain(true);
@ -60,7 +61,7 @@ public class CreateClassificationAccTest extends AbstractAccTest {
@Test
public void testCreateClassificationWithRootCopy()
throws ClassificationAlreadyExistException, ClassificationNotFoundException, NotAuthorizedException,
DomainNotFoundException {
DomainNotFoundException, InvalidArgumentException {
long amountOfClassificationsBefore = classificationService.createClassificationQuery().count();
Classification classification = classificationService.newClassification("Key1", "DOMAIN_A", "TASK");
classification.setIsValidInDomain(true);
@ -101,14 +102,14 @@ public class CreateClassificationAccTest extends AbstractAccTest {
@Test
public void testCreateClassificationWithInvalidValues()
throws ClassificationAlreadyExistException, NotAuthorizedException, ClassificationNotFoundException,
DomainNotFoundException {
DomainNotFoundException, InvalidArgumentException {
long amountOfClassificationsBefore = classificationService.createClassificationQuery().count();
// Check key NULL
try {
Classification classification = classificationService.newClassification(null, "DOMAIN_A", "TASK");
classification = classificationService.createClassification(classification);
} catch (IllegalStateException e) {
} catch (InvalidArgumentException e) {
// nothing to do
}
@ -117,7 +118,7 @@ public class CreateClassificationAccTest extends AbstractAccTest {
Classification classification = classificationService.newClassification("Key2", "DOMAIN_B", "TASK");
classification.setServiceLevel("abc");
classification = classificationService.createClassification(classification);
} catch (IllegalArgumentException e) {
} catch (InvalidArgumentException e) {
// nothing to do
}
}
@ -128,7 +129,7 @@ public class CreateClassificationAccTest extends AbstractAccTest {
@Test(expected = ClassificationAlreadyExistException.class)
public void testCreateClassificationAlreadyExisting()
throws ClassificationAlreadyExistException, NotAuthorizedException, ClassificationNotFoundException,
DomainNotFoundException {
DomainNotFoundException, InvalidArgumentException {
Classification classification = classificationService.newClassification("Key3", "", "TASK");
classification = classificationService.createClassification(classification);
classification = classificationService.createClassification(classification);
@ -140,18 +141,29 @@ public class CreateClassificationAccTest extends AbstractAccTest {
@Test(expected = DomainNotFoundException.class)
public void testCreateClassificationInUnknownDomain()
throws ClassificationAlreadyExistException, NotAuthorizedException, ClassificationNotFoundException,
DomainNotFoundException {
DomainNotFoundException, InvalidArgumentException {
Classification classification = classificationService.newClassification("Key3", "UNKNOWN_DOMAIN", "TASK");
classification = classificationService.createClassification(classification);
}
@WithAccessId(
userName = "teamlead_1",
groupNames = {"group_1", "businessadmin"})
@Test(expected = InvalidArgumentException.class)
public void testCreateClassificationOfUnknownType()
throws ClassificationAlreadyExistException, NotAuthorizedException, ClassificationNotFoundException,
DomainNotFoundException, InvalidArgumentException {
Classification classification = classificationService.newClassification("Key3", "DOMAIN_A", "UNKNOWN_TYPE");
classification = classificationService.createClassification(classification);
}
@WithAccessId(
userName = "teamlead_1",
groupNames = {"group_1", "businessadmin"})
@Test(expected = ClassificationNotFoundException.class)
public void testCreateClassificationWithInvalidParent()
throws ClassificationAlreadyExistException, NotAuthorizedException, ClassificationNotFoundException,
DomainNotFoundException {
DomainNotFoundException, InvalidArgumentException {
Classification classification = classificationService.newClassification("Key4", "", "TASK");
classification.setParentId("ID WHICH CANT BE FOUND");
classification = classificationService.createClassification(classification);

11
lib/taskana-core/src/test/java/acceptance/classification/UpdateClassificationAccTest.java
View File

@ -50,7 +50,8 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
groupNames = {"businessadmin"})
@Test
public void testUpdateClassification()
throws SQLException, ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException {
throws SQLException, ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException,
InvalidArgumentException {
String newName = "updated Name";
String newEntryPoint = "updated EntryPoint";
ClassificationService classificationService = taskanaEngine.getClassificationService();
@ -88,7 +89,8 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
@Test(expected = NotAuthorizedException.class)
public void testUpdateClassificationFails()
throws SQLException, ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException {
throws SQLException, ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException,
InvalidArgumentException {
String newName = "updated Name";
String newEntryPoint = "updated EntryPoint";
ClassificationService classificationService = taskanaEngine.getClassificationService();
@ -149,7 +151,8 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
groupNames = {"group_1", "businessadmin"})
@Test(expected = ConcurrencyException.class)
public void testUpdateClassificationNotLatestAnymore()
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException, InterruptedException {
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException, InterruptedException,
InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
Classification base = classificationService.getClassification("T2100", "DOMAIN_A");
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
@ -173,7 +176,7 @@ public class UpdateClassificationAccTest extends AbstractAccTest {
@Test(expected = ClassificationNotFoundException.class)
public void testUpdateClassificationParentToInvalid()
throws NotAuthorizedException, ClassificationNotFoundException,
ConcurrencyException {
ConcurrencyException, InvalidArgumentException {
ClassificationService classificationService = taskanaEngine.getClassificationService();
Classification classification = classificationService.getClassification("T2100", "DOMAIN_A");
classification.setParentId("ID WHICH CANT BE FOUND");

9
lib/taskana-core/src/test/java/acceptance/config/TaskanaConfigAccTest.java
View File

@ -32,4 +32,13 @@ public class TaskanaConfigAccTest extends TaskanaEngineImpl {
}
@Test
public void testClassificationTypes() {
assertEquals(2, getConfiguration().getClassificationTypes().size());
assertTrue(getConfiguration().getClassificationTypes().contains("TASK"));
assertTrue(getConfiguration().getClassificationTypes().contains("DOCUMENT"));
assertFalse(getConfiguration().getClassificationTypes().contains("document"));
}
}

15
lib/taskana-core/src/test/java/pro/taskana/impl/ClassificationServiceImplTest.java
View File

@ -27,6 +27,7 @@ import pro.taskana.exceptions.ClassificationAlreadyExistException;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.ConcurrencyException;
import pro.taskana.exceptions.DomainNotFoundException;
import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.mappings.ClassificationMapper;
@ -62,7 +63,7 @@ public class ClassificationServiceImplTest {
@Test(expected = ClassificationAlreadyExistException.class)
public void testCreateClassificationAlreadyExisting()
throws ClassificationAlreadyExistException, ClassificationNotFoundException, NotAuthorizedException,
DomainNotFoundException {
DomainNotFoundException, InvalidArgumentException {
Classification classification = createDummyClassification();
doReturn(classification).when(classificationMapperMock).findByKeyAndDomain(classification.getKey(),
classification.getDomain());
@ -85,7 +86,7 @@ public class ClassificationServiceImplTest {
@Test(expected = ClassificationNotFoundException.class)
public void testCreateClassificationParentNotExisting()
throws ClassificationAlreadyExistException, ClassificationNotFoundException, NotAuthorizedException,
DomainNotFoundException {
DomainNotFoundException, InvalidArgumentException {
Classification classification = createDummyClassification();
classification.setParentId("NOT EXISTING ID");
doReturn(null).when(classificationMapperMock).findByKeyAndDomain(classification.getKey(),
@ -112,7 +113,7 @@ public class ClassificationServiceImplTest {
@Test
public void testCreateClassificationInOwnDomainButExistingInRoot()
throws ClassificationAlreadyExistException, ClassificationNotFoundException, InterruptedException,
NotAuthorizedException, DomainNotFoundException {
NotAuthorizedException, DomainNotFoundException, InvalidArgumentException {
Instant beforeTimestamp = Instant.now();
Thread.sleep(10L);
Classification classification = createDummyClassification();
@ -145,7 +146,7 @@ public class ClassificationServiceImplTest {
@Test
public void testCreateClassificationInOwnDomainAndCopyInRootDomain()
throws ClassificationAlreadyExistException, NotAuthorizedException, ClassificationNotFoundException,
DomainNotFoundException {
DomainNotFoundException, InvalidArgumentException {
Classification classification = createDummyClassification();
String domain = classification.getDomain();
String key = classification.getKey();
@ -172,7 +173,7 @@ public class ClassificationServiceImplTest {
@Test
public void testCreateClassificationIntoRootDomain()
throws ClassificationAlreadyExistException, NotAuthorizedException, ClassificationNotFoundException,
DomainNotFoundException {
DomainNotFoundException, InvalidArgumentException {
ClassificationImpl classification = (ClassificationImpl) createDummyClassification();
classification.setDomain("");
doReturn(null).when(classificationMapperMock).findByKeyAndDomain(classification.getKey(),
@ -193,7 +194,7 @@ public class ClassificationServiceImplTest {
@Test
public void testUpdateExistingClassification()
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException {
throws ClassificationNotFoundException, NotAuthorizedException, ConcurrencyException, InvalidArgumentException {
Instant now = Instant.now();
Classification classification = createDummyClassification();
((ClassificationImpl) classification).setModified(now);
@ -214,7 +215,7 @@ public class ClassificationServiceImplTest {
@Test(expected = ClassificationNotFoundException.class)
public void testUpdateClassificationParentNotExisting()
throws ClassificationAlreadyExistException, ClassificationNotFoundException, NotAuthorizedException,
ConcurrencyException {
ConcurrencyException, InvalidArgumentException {
Instant now = Instant.now();
ClassificationImpl oldClassification = (ClassificationImpl) createDummyClassification();
oldClassification.setParentId("SOME ID");

80
lib/taskana-core/src/test/java/pro/taskana/impl/integration/ClassificationServiceImplIntAutoCommitTest.java
View File

@ -84,7 +84,7 @@ public class ClassificationServiceImplIntAutoCommitTest {
Classification actualClassification2;
// empty classification (root)
expectedClassification = (ClassificationImpl) this.createDummyClassificationWithUniqueKey("", "type1");
expectedClassification = (ClassificationImpl) this.createDummyClassificationWithUniqueKey("", "TASK");
expectedClassification = (ClassificationImpl) classificationService
.createClassification(expectedClassification);
actualClassification = classificationService.getClassification(expectedClassification.getKey(),
@ -95,7 +95,7 @@ public class ClassificationServiceImplIntAutoCommitTest {
assertThat(actualClassification.getId(), startsWith(ID_PREFIX_CLASSIFICATION));
// specific to domain + root
expectedClassification = (ClassificationImpl) this.createDummyClassificationWithUniqueKey(domain, "type1");
expectedClassification = (ClassificationImpl) this.createDummyClassificationWithUniqueKey(domain, "TASK");
expectedClassification.setKey(key);
expectedClassification = (ClassificationImpl) classificationService
.createClassification(expectedClassification);
@ -118,7 +118,7 @@ public class ClassificationServiceImplIntAutoCommitTest {
// does exist already
try {
expectedClassification = (ClassificationImpl) this.createDummyClassificationWithUniqueKey(domain, "type1");
expectedClassification = (ClassificationImpl) this.createDummyClassificationWithUniqueKey(domain, "TASK");
expectedClassification.setKey(key);
classificationService.createClassification(expectedClassification);
fail("Should have thrown 'ClassificationAlreadyExistException' here.");
@ -127,7 +127,7 @@ public class ClassificationServiceImplIntAutoCommitTest {
// new classification but root existing
expectedClassification = (ClassificationImpl) this.createDummyClassificationWithUniqueKey("DOMAIN_B",
"type1");
"TASK");
expectedClassification.setKey(key);
classificationService.createClassification(expectedClassification);
actualClassification = classificationService.getClassification(key, "DOMAIN_B");
@ -143,25 +143,25 @@ public class ClassificationServiceImplIntAutoCommitTest {
// invalid serviceLevel
try {
expectedClassification = (ClassificationImpl) this.createDummyClassificationWithUniqueKey(domain + "_3",
"type1");
expectedClassification = (ClassificationImpl) this.createDummyClassificationWithUniqueKey(domain,
"TASK");
expectedClassification.setKey("");
expectedClassification.setServiceLevel("ASAP");
classificationService.createClassification(expectedClassification);
fail("Should have thrown IllegalArgumentException, because ServiceLevel is invalid.");
} catch (IllegalArgumentException e) {
} catch (InvalidArgumentException e) {
}
}
@Test
public void testFindAllClassifications()
throws ClassificationAlreadyExistException, NotAuthorizedException, ClassificationNotFoundException,
DomainNotFoundException {
Classification classification0 = this.createDummyClassificationWithUniqueKey("", "type1");
DomainNotFoundException, InvalidArgumentException {
Classification classification0 = this.createDummyClassificationWithUniqueKey("", "TASK");
classificationService.createClassification(classification0);
Classification classification1 = this.createDummyClassificationWithUniqueKey("", "type1");
Classification classification1 = this.createDummyClassificationWithUniqueKey("", "TASK");
classificationService.createClassification(classification1);
Classification classification2 = this.createDummyClassificationWithUniqueKey("", "type1");
Classification classification2 = this.createDummyClassificationWithUniqueKey("", "TASK");
classification2.setParentId(classification0.getId());
classificationService.createClassification(classification2);
@ -171,9 +171,9 @@ public class ClassificationServiceImplIntAutoCommitTest {
@Test
public void testModifiedClassification()
throws ClassificationAlreadyExistException, ClassificationNotFoundException, NotAuthorizedException,
ConcurrencyException, DomainNotFoundException {
ConcurrencyException, DomainNotFoundException, InvalidArgumentException {
String description = "TEST SOMETHING";
Classification classification = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "type1");
Classification classification = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "TASK");
classification.setDescription("");
classification = classificationService.createClassification(classification);
classification.setDescription("TEST SOMETHING");
@ -187,7 +187,7 @@ public class ClassificationServiceImplIntAutoCommitTest {
public void testInsertAndClassificationMapper()
throws NotAuthorizedException, ClassificationAlreadyExistException, ClassificationNotFoundException,
InvalidArgumentException, DomainNotFoundException {
Classification classification = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "type1");
Classification classification = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "TASK");
classification = classificationService.createClassification(classification);
List<ClassificationSummary> list = classificationService.createClassificationQuery()
@ -201,8 +201,8 @@ public class ClassificationServiceImplIntAutoCommitTest {
@Test
public void testUpdateAndClassificationMapper()
throws NotAuthorizedException, ClassificationAlreadyExistException, ClassificationNotFoundException,
ConcurrencyException, DomainNotFoundException {
Classification classification = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "type1");
ConcurrencyException, DomainNotFoundException, InvalidArgumentException {
Classification classification = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "TASK");
classification = classificationService.createClassification(classification);
classification.setDescription("description");
classification = classificationService.updateClassification(classification);
@ -224,14 +224,14 @@ public class ClassificationServiceImplIntAutoCommitTest {
@Test
public void testFindWithClassificationMapperDomainAndCategory()
throws ClassificationAlreadyExistException, NotAuthorizedException, ClassificationNotFoundException,
DomainNotFoundException {
Classification classification1 = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "type1");
DomainNotFoundException, InvalidArgumentException {
Classification classification1 = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "TASK");
classification1.setCategory("category1");
classificationService.createClassification(classification1);
Classification classification2 = this.createDummyClassificationWithUniqueKey("DOMAIN_B", "type1");
Classification classification2 = this.createDummyClassificationWithUniqueKey("DOMAIN_B", "TASK");
classification2.setCategory("category1");
classificationService.createClassification(classification2);
Classification classification3 = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "type1");
Classification classification3 = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "TASK");
classification3.setCategory("category2");
classificationService.createClassification(classification3);
@ -247,22 +247,22 @@ public class ClassificationServiceImplIntAutoCommitTest {
@Test
public void testFindWithClassificationMapperCustomAndCategory()
throws ClassificationAlreadyExistException, NotAuthorizedException, ClassificationNotFoundException,
DomainNotFoundException {
Classification classification1 = this.createDummyClassificationWithUniqueKey("", "type1");
DomainNotFoundException, InvalidArgumentException {
Classification classification1 = this.createDummyClassificationWithUniqueKey("", "TASK");
classification1.setDescription("DESC1");
classification1.setCategory("category1");
classificationService.createClassification(classification1);
Classification classification2 = this.createDummyClassificationWithUniqueKey("", "type1");
Classification classification2 = this.createDummyClassificationWithUniqueKey("", "TASK");
classification2.setDescription("DESC1");
classification2.setCustom1("custom1");
classification2.setCategory("category1");
classificationService.createClassification(classification2);
Classification classification3 = this.createDummyClassificationWithUniqueKey("", "type1");
Classification classification3 = this.createDummyClassificationWithUniqueKey("", "TASK");
classification3.setCustom1("custom2");
classification3.setCustom2("custom1");
classification3.setCategory("category2");
classificationService.createClassification(classification3);
Classification classification4 = this.createDummyClassificationWithUniqueKey("", "type1");
Classification classification4 = this.createDummyClassificationWithUniqueKey("", "TASK");
classification4.setDescription("description2");
classification4.setCustom8("custom2");
classification4.setCategory("category1");
@ -285,20 +285,20 @@ public class ClassificationServiceImplIntAutoCommitTest {
@Test
public void testFindWithClassificationMapperPriorityTypeAndParent()
throws ClassificationAlreadyExistException, NumberFormatException, NotAuthorizedException,
ClassificationNotFoundException, DomainNotFoundException {
Classification classification = this.createDummyClassificationWithUniqueKey("", "type1");
ClassificationNotFoundException, DomainNotFoundException, InvalidArgumentException {
Classification classification = this.createDummyClassificationWithUniqueKey("", "TASK");
classification.setPriority(Integer.decode("5"));
classificationService.createClassification(classification);
Classification classification1 = this.createDummyClassificationWithUniqueKey("", "type1");
Classification classification1 = this.createDummyClassificationWithUniqueKey("", "TASK");
classification1.setPriority(Integer.decode("3"));
classification1.setParentId(classification.getId());
classificationService.createClassification(classification1);
Classification classification2 = this.createDummyClassificationWithUniqueKey("", "type2");
Classification classification2 = this.createDummyClassificationWithUniqueKey("", "DOCUMENT");
classification2.setPriority(Integer.decode("5"));
classification2.setParentId(classification.getId());
classificationService.createClassification(classification2);
Classification classification3 = this.createDummyClassificationWithUniqueKey("", "type1");
Classification classification3 = this.createDummyClassificationWithUniqueKey("", "TASK");
classification3.setPriority(Integer.decode("5"));
classification3.setParentId(classification1.getId());
classificationService.createClassification(classification3);
@ -307,11 +307,11 @@ public class ClassificationServiceImplIntAutoCommitTest {
.parentIdIn(classification.getId())
.list();
Assert.assertEquals(2, list.size());
list = classificationService.createClassificationQuery().typeIn("type1").priorityIn(Integer.decode("5")).list();
list = classificationService.createClassificationQuery().typeIn("TASK").priorityIn(Integer.decode("5")).list();
Assert.assertEquals(2, list.size());
list = classificationService.createClassificationQuery()
.priorityIn(Integer.decode("5"))
.typeIn("type1")
.typeIn("TASK")
.parentIdIn(classification1.getId())
.list();
Assert.assertEquals(1, list.size());
@ -320,27 +320,27 @@ public class ClassificationServiceImplIntAutoCommitTest {
@Test
public void testFindWithClassificationMapperServiceLevelNameAndDescription()
throws ClassificationAlreadyExistException, NotAuthorizedException, ClassificationNotFoundException,
DomainNotFoundException {
DomainNotFoundException, InvalidArgumentException {
int all = 0;
Classification classification = this.createDummyClassificationWithUniqueKey("", "type1");
Classification classification = this.createDummyClassificationWithUniqueKey("", "TASK");
classification.setServiceLevel("P1D");
classification.setName("name1");
classification.setDescription("desc");
classificationService.createClassification(classification);
all++;
Classification classification1 = this.createDummyClassificationWithUniqueKey("", "type1");
Classification classification1 = this.createDummyClassificationWithUniqueKey("", "TASK");
classification1.setServiceLevel("P1DT1H");
classification1.setName("name1");
classification1.setDescription("desc");
classificationService.createClassification(classification1);
all++;
Classification classification2 = this.createDummyClassificationWithUniqueKey("", "type1");
Classification classification2 = this.createDummyClassificationWithUniqueKey("", "TASK");
classification2.setServiceLevel("P1D");
classification2.setName("name");
classification2.setDescription("desc");
classificationService.createClassification(classification2);
all++;
Classification classification3 = this.createDummyClassificationWithUniqueKey("", "type1");
Classification classification3 = this.createDummyClassificationWithUniqueKey("", "TASK");
classification3.setName("name1");
classification3.setDescription("description");
classificationService.createClassification(classification3);
@ -359,11 +359,11 @@ public class ClassificationServiceImplIntAutoCommitTest {
@Test
public void testDefaultSettingsWithClassificationMapper()
throws NotAuthorizedException, ClassificationAlreadyExistException, ClassificationNotFoundException,
ConcurrencyException, DomainNotFoundException {
Classification classification = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "type1");
ConcurrencyException, DomainNotFoundException, InvalidArgumentException {
Classification classification = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "TASK");
classification = classificationService.createClassification(classification);
Classification classification1 = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "type1");
Classification classification1 = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "TASK");
classification1 = classificationService.createClassification(classification1);
classification1.setParentId(classification.getId());

82
lib/taskana-core/src/test/java/pro/taskana/impl/integration/ClassificationServiceImplIntExplicitTest.java
View File

@ -79,7 +79,7 @@ public class ClassificationServiceImplIntExplicitTest {
@Test
public void testInsertClassification()
throws SQLException, ClassificationNotFoundException, ClassificationAlreadyExistException,
NotAuthorizedException, DomainNotFoundException {
NotAuthorizedException, DomainNotFoundException, InvalidArgumentException {
Connection connection = dataSource.getConnection();
taskanaEngineImpl.setConnection(connection);
@ -90,7 +90,7 @@ public class ClassificationServiceImplIntExplicitTest {
Classification actualClassification2;
// empty classification (root)
expectedClassification = (ClassificationImpl) this.createNewClassificationWithUniqueKey("", "t1");
expectedClassification = (ClassificationImpl) this.createNewClassificationWithUniqueKey("", "TASK");
expectedClassification = (ClassificationImpl) classificationService
.createClassification(expectedClassification);
connection.commit();
@ -102,7 +102,7 @@ public class ClassificationServiceImplIntExplicitTest {
assertThat(actualClassification.getId(), startsWith(ID_PREFIX_CLASSIFICATION));
// specific to domain + root
expectedClassification = (ClassificationImpl) this.createNewClassificationWithUniqueKey(domain, "t1");
expectedClassification = (ClassificationImpl) this.createNewClassificationWithUniqueKey(domain, "TASK");
expectedClassification.setKey(key);
expectedClassification = (ClassificationImpl) classificationService
.createClassification(expectedClassification);
@ -126,7 +126,7 @@ public class ClassificationServiceImplIntExplicitTest {
// does exist already
try {
expectedClassification = (ClassificationImpl) this.createNewClassificationWithUniqueKey(domain, "t1");
expectedClassification = (ClassificationImpl) this.createNewClassificationWithUniqueKey(domain, "TASK");
expectedClassification.setKey(key);
classificationService.createClassification(expectedClassification);
connection.commit();
@ -135,7 +135,7 @@ public class ClassificationServiceImplIntExplicitTest {
}
// new classification but root existing
expectedClassification = (ClassificationImpl) this.createNewClassificationWithUniqueKey("", "t1");
expectedClassification = (ClassificationImpl) this.createNewClassificationWithUniqueKey("", "TASK");
expectedClassification.setKey(key);
expectedClassification.setDomain("DOMAIN_B");
classificationService.createClassification(expectedClassification);
@ -152,28 +152,28 @@ public class ClassificationServiceImplIntExplicitTest {
// invalid serviceLevel
try {
expectedClassification = (ClassificationImpl) this.createNewClassificationWithUniqueKey("", "t1");
expectedClassification.setDomain(domain + "_3");
expectedClassification = (ClassificationImpl) this.createNewClassificationWithUniqueKey("", "TASK");
expectedClassification.setDomain(domain);
expectedClassification.setKey("");
expectedClassification.setServiceLevel("ASAP");
classificationService.createClassification(expectedClassification);
connection.commit();
fail("Should have thrown IllegalArgumentException, because ServiceLevel is invalid.");
} catch (IllegalArgumentException e) {
} catch (InvalidArgumentException e) {
}
}
@Test
public void testFindAllClassifications()
throws SQLException, ClassificationAlreadyExistException, NotAuthorizedException,
ClassificationNotFoundException, DomainNotFoundException {
ClassificationNotFoundException, DomainNotFoundException, InvalidArgumentException {
Connection connection = dataSource.getConnection();
taskanaEngineImpl.setConnection(connection);
Classification classification0 = this.createNewClassificationWithUniqueKey("", "t1");
Classification classification0 = this.createNewClassificationWithUniqueKey("", "TASK");
classificationService.createClassification(classification0);
Classification classification1 = this.createNewClassificationWithUniqueKey("", "t1");
Classification classification1 = this.createNewClassificationWithUniqueKey("", "TASK");
classificationService.createClassification(classification1);
Classification classification2 = this.createNewClassificationWithUniqueKey("", "t1");
Classification classification2 = this.createNewClassificationWithUniqueKey("", "TASK");
classification2.setParentId(classification0.getId());
classificationService.createClassification(classification2);
@ -184,11 +184,11 @@ public class ClassificationServiceImplIntExplicitTest {
@Test
public void testModifiedClassification()
throws SQLException, ClassificationAlreadyExistException, ClassificationNotFoundException,
NotAuthorizedException, ConcurrencyException, DomainNotFoundException {
NotAuthorizedException, ConcurrencyException, DomainNotFoundException, InvalidArgumentException {
Connection connection = dataSource.getConnection();
taskanaEngineImpl.setConnection(connection);
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "t1");
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
connection.commit();
classification = classificationService.createClassification(classification);
@ -204,10 +204,10 @@ public class ClassificationServiceImplIntExplicitTest {
@Test
public void testInsertAndClassificationQuery()
throws SQLException, ClassificationAlreadyExistException, NotAuthorizedException,
ClassificationNotFoundException, DomainNotFoundException {
ClassificationNotFoundException, DomainNotFoundException, InvalidArgumentException {
Connection connection = dataSource.getConnection();
taskanaEngineImpl.setConnection(connection);
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "t1");
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
classificationService.createClassification(classification);
List<ClassificationSummary> list = classificationService.createClassificationQuery()
.validInDomainEquals(Boolean.TRUE)
@ -219,10 +219,10 @@ public class ClassificationServiceImplIntExplicitTest {
@Test
public void testUpdateAndClassificationQuery() throws NotAuthorizedException, SQLException,
ClassificationAlreadyExistException, ClassificationNotFoundException, ConcurrencyException,
DomainNotFoundException {
DomainNotFoundException, InvalidArgumentException {
Connection connection = dataSource.getConnection();
taskanaEngineImpl.setConnection(connection);
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "t1");
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
classification.setDescription("");
classification = classificationService.createClassification(classification);
classification.setDescription("description");
@ -249,17 +249,17 @@ public class ClassificationServiceImplIntExplicitTest {
@Test
public void testFindWithClassificationMapperDomainAndCategory()
throws SQLException, ClassificationAlreadyExistException, NotAuthorizedException,
ClassificationNotFoundException, DomainNotFoundException {
ClassificationNotFoundException, DomainNotFoundException, InvalidArgumentException {
Connection connection = dataSource.getConnection();
taskanaEngineImpl.setConnection(connection);
Classification classification1 = this.createNewClassificationWithUniqueKey("DOMAIN_A", "t1");
Classification classification1 = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
classification1.setCategory("category1");
classificationService.createClassification(classification1);
Classification classification2 = this.createNewClassificationWithUniqueKey("DOMAIN_B", "t1");
Classification classification2 = this.createNewClassificationWithUniqueKey("DOMAIN_B", "TASK");
classification2.setCategory("category1");
classificationService.createClassification(classification2);
Classification classification3 = this.createNewClassificationWithUniqueKey("DOMAIN_A", "t1");
Classification classification3 = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
classification3.setCategory("category2");
classificationService.createClassification(classification3);
@ -276,24 +276,24 @@ public class ClassificationServiceImplIntExplicitTest {
@Test
public void testFindWithClassificationMapperCustomAndCategory()
throws SQLException, ClassificationAlreadyExistException, NotAuthorizedException,
ClassificationNotFoundException, DomainNotFoundException {
ClassificationNotFoundException, DomainNotFoundException, InvalidArgumentException {
Connection connection = dataSource.getConnection();
taskanaEngineImpl.setConnection(connection);
Classification classification1 = this.createNewClassificationWithUniqueKey("", "t1");
Classification classification1 = this.createNewClassificationWithUniqueKey("", "TASK");
classification1.setDescription("DESC1");
classification1.setCategory("category1");
classificationService.createClassification(classification1);
Classification classification2 = this.createNewClassificationWithUniqueKey("", "t1");
Classification classification2 = this.createNewClassificationWithUniqueKey("", "TASK");
classification2.setDescription("DESC1");
classification2.setCustom1("custom1");
classification2.setCategory("category1");
classificationService.createClassification(classification2);
Classification classification3 = this.createNewClassificationWithUniqueKey("", "t1");
Classification classification3 = this.createNewClassificationWithUniqueKey("", "TASK");
classification3.setCustom1("custom2");
classification3.setCustom2("custom1");
classification3.setCategory("category2");
classificationService.createClassification(classification3);
Classification classification4 = this.createNewClassificationWithUniqueKey("", "t1");
Classification classification4 = this.createNewClassificationWithUniqueKey("", "TASK");
classification4.setDescription("description2");
classification4.setCustom8("custom2");
classification4.setCategory("category1");
@ -317,21 +317,21 @@ public class ClassificationServiceImplIntExplicitTest {
@Test
public void testFindWithClassificationMapperPriorityTypeAndParent()
throws SQLException, ClassificationAlreadyExistException, NotAuthorizedException,
ClassificationNotFoundException, DomainNotFoundException {
ClassificationNotFoundException, DomainNotFoundException, InvalidArgumentException {
Connection connection = dataSource.getConnection();
taskanaEngineImpl.setConnection(connection);
Classification classification = this.createNewClassificationWithUniqueKey("", "type1");
Classification classification = this.createNewClassificationWithUniqueKey("", "TASK");
classification.setPriority(Integer.decode("5"));
classificationService.createClassification(classification);
Classification classification1 = this.createNewClassificationWithUniqueKey("", "type1");
Classification classification1 = this.createNewClassificationWithUniqueKey("", "TASK");
classification1.setPriority(Integer.decode("3"));
classification1.setParentId(classification.getId());
classificationService.createClassification(classification1);
Classification classification2 = this.createNewClassificationWithUniqueKey("", "type2");
Classification classification2 = this.createNewClassificationWithUniqueKey("", "DOCUMENT");
classification2.setPriority(Integer.decode("5"));
classification2.setParentId(classification.getId());
classificationService.createClassification(classification2);
Classification classification3 = this.createNewClassificationWithUniqueKey("", "type1");
Classification classification3 = this.createNewClassificationWithUniqueKey("", "TASK");
classification3.setPriority(Integer.decode("5"));
classification3.setParentId(classification1.getId());
classificationService.createClassification(classification3);
@ -340,11 +340,11 @@ public class ClassificationServiceImplIntExplicitTest {
.parentIdIn(classification.getId())
.list();
Assert.assertEquals(2, list.size());
list = classificationService.createClassificationQuery().typeIn("type1").priorityIn(Integer.decode("5")).list();
list = classificationService.createClassificationQuery().typeIn("TASK").priorityIn(Integer.decode("5")).list();
Assert.assertEquals(2, list.size());
list = classificationService.createClassificationQuery()
.priorityIn(Integer.decode("5"))
.typeIn("type1")
.typeIn("TASK")
.parentIdIn(classification1.getId())
.list();
Assert.assertEquals(1, list.size());
@ -354,29 +354,29 @@ public class ClassificationServiceImplIntExplicitTest {
@Test
public void testFindWithClassificationMapperServiceLevelNameAndDescription()
throws NotAuthorizedException, SQLException, ClassificationAlreadyExistException,
ClassificationNotFoundException, DomainNotFoundException {
ClassificationNotFoundException, DomainNotFoundException, InvalidArgumentException {
Connection connection = dataSource.getConnection();
taskanaEngineImpl.setConnection(connection);
int all = 0;
Classification classification = this.createNewClassificationWithUniqueKey("", "type1");
Classification classification = this.createNewClassificationWithUniqueKey("", "TASK");
classification.setServiceLevel("P1D");
classification.setName("name1");
classification.setDescription("desc");
classificationService.createClassification(classification);
all++;
Classification classification1 = this.createNewClassificationWithUniqueKey("", "type1");
Classification classification1 = this.createNewClassificationWithUniqueKey("", "TASK");
classification1.setServiceLevel("P1DT1H");
classification1.setName("name1");
classification1.setDescription("desc");
classificationService.createClassification(classification1);
all++;
Classification classification2 = this.createNewClassificationWithUniqueKey("", "type1");
Classification classification2 = this.createNewClassificationWithUniqueKey("", "TASK");
classification2.setServiceLevel("P1D");
classification2.setName("name");
classification2.setDescription("desc");
classificationService.createClassification(classification2);
all++;
Classification classification3 = this.createNewClassificationWithUniqueKey("", "type1");
Classification classification3 = this.createNewClassificationWithUniqueKey("", "TASK");
classification3.setName("name1");
classification3.setDescription("description");
classificationService.createClassification(classification3);
@ -399,10 +399,10 @@ public class ClassificationServiceImplIntExplicitTest {
ConcurrencyException, DomainNotFoundException {
Connection connection = dataSource.getConnection();
taskanaEngineImpl.setConnection(connection);
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "type1");
Classification classification = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
classification = classificationService.createClassification(classification);
Classification classification1 = this.createNewClassificationWithUniqueKey("DOMAIN_A", "type1");
Classification classification1 = this.createNewClassificationWithUniqueKey("DOMAIN_A", "TASK");
classification1 = classificationService.createClassification(classification1);
classification1.setParentId(classification.getId());
classification1 = classificationService.updateClassification(classification1);

14
lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntAutocommitTest.java
View File

@ -103,7 +103,7 @@ public class TaskServiceImplIntAutocommitTest {
wb.setName("workbasket");
wb.setType(WorkbasketType.GROUP);
taskanaEngine.getWorkbasketService().createWorkbasket(wb);
Classification classification = classificationService.newClassification("TEST", "DOMAIN_A", "t1");
Classification classification = classificationService.newClassification("TEST", "DOMAIN_A", "TASK");
taskanaEngine.getClassificationService().createClassification(classification);
Task task = taskServiceImpl.newTask(wb.getId());
@ -131,7 +131,7 @@ public class TaskServiceImplIntAutocommitTest {
wb.setType(WorkbasketType.GROUP);
taskanaEngine.getWorkbasketService().createWorkbasket(wb);
Classification classification = classificationService.newClassification("TEST", "DOMAIN_A", "t1");
Classification classification = classificationService.newClassification("TEST", "DOMAIN_A", "TASK");
classification = taskanaEngine.getClassificationService()
.createClassification(classification);
classification = taskanaEngine.getClassificationService().getClassification(
@ -167,7 +167,7 @@ public class TaskServiceImplIntAutocommitTest {
wb.setName("workbasket");
wb.setType(WorkbasketType.GROUP);
te.getWorkbasketService().createWorkbasket(wb);
Classification classification = te.getClassificationService().newClassification("TEST", "DOMAIN_A", "t1");
Classification classification = te.getClassificationService().newClassification("TEST", "DOMAIN_A", "TASK");
te.getClassificationService().createClassification(classification);
Task task = taskServiceImpl.newTask(wb.getId());
@ -189,7 +189,7 @@ public class TaskServiceImplIntAutocommitTest {
wb.setName("workbasket");
wb.setType(WorkbasketType.GROUP);
taskanaEngine.getWorkbasketService().createWorkbasket(wb);
Classification classification = classificationService.newClassification("TEST", "DOMAIN_A", "t1");
Classification classification = classificationService.newClassification("TEST", "DOMAIN_A", "TASK");
taskanaEngine.getClassificationService().createClassification(classification);
Task task = taskServiceImpl.newTask(wb.getKey(), wb.getDomain());
@ -248,7 +248,7 @@ public class TaskServiceImplIntAutocommitTest {
destinationWB = workbasketService.createWorkbasket(wb);
// Classification required for Task
classification = (ClassificationImpl) classificationService.newClassification("KEY", "DOMAIN_A", "t1");
classification = (ClassificationImpl) classificationService.newClassification("KEY", "DOMAIN_A", "TASK");
classification.setCategory("Test Classification");
classification.setName("Transfert-Task Classification");
classificationService.createClassification(classification);
@ -301,7 +301,7 @@ public class TaskServiceImplIntAutocommitTest {
workbasketService = taskanaEngine.getWorkbasketService();
ClassificationImpl classification = (ClassificationImpl) classificationService.newClassification("KEY",
"DOMAIN_A", "t1");
"DOMAIN_A", "TASK");
classification.setCategory("Test Classification");
classification.setName("Transfert-Task Classification");
classificationService.createClassification(classification);
@ -379,7 +379,7 @@ public class TaskServiceImplIntAutocommitTest {
wb.setName("workbasket");
wb.setType(WorkbasketType.GROUP);
taskanaEngine.getWorkbasketService().createWorkbasket(wb);
Classification classification = classificationService.newClassification("TEST", "DOMAIN_A", "t1");
Classification classification = classificationService.newClassification("TEST", "DOMAIN_A", "TASK");
taskanaEngine.getClassificationService().createClassification(classification);
Task task = taskServiceImpl.newTask(wb.getId());

14
lib/taskana-core/src/test/java/pro/taskana/impl/integration/TaskServiceImplIntExplicitTest.java
View File

@ -115,7 +115,7 @@ public class TaskServiceImplIntExplicitTest {
workbasket.setId("1"); // set id manually for authorization tests
workbasket.setType(WorkbasketType.GROUP);
Classification classification = classificationService.newClassification("TEST", "DOMAIN_A", "type1");
Classification classification = classificationService.newClassification("TEST", "DOMAIN_A", "TASK");
taskanaEngineImpl.getWorkbasketService().createWorkbasket(workbasket);
taskanaEngineImpl.getClassificationService().createClassification(classification);
connection.commit();
@ -189,7 +189,7 @@ public class TaskServiceImplIntExplicitTest {
workbasket.setName("workbasket99");
workbasket.setType(WorkbasketType.GROUP);
workbasket = workBasketServiceImpl.createWorkbasket(workbasket);
Classification classification = classificationService.newClassification("TEST", "DOMAIN_A", "t1");
Classification classification = classificationService.newClassification("TEST", "DOMAIN_A", "TASK");
classification = classificationServiceImpl.createClassification(classification);
Task task = taskServiceImpl.newTask(workbasket.getId());
@ -262,7 +262,7 @@ public class TaskServiceImplIntExplicitTest {
WorkbasketImpl workbasket = (WorkbasketImpl) workbasketService.newWorkbasket("k1", "DOMAIN_A");
workbasket.setName("workbasket");
Classification classification = classificationService.newClassification("TEST", "DOMAIN_A", "t1");
Classification classification = classificationService.newClassification("TEST", "DOMAIN_A", "TASK");
classificationService.createClassification(classification);
workbasket.setId("1"); // set id manually for authorization tests
workbasket.setType(WorkbasketType.GROUP);
@ -334,7 +334,7 @@ public class TaskServiceImplIntExplicitTest {
createWorkbasketWithSecurity(destinationWB, destinationWB.getOwner(), false, true, true, true);
// Classification required for Task
classification = (ClassificationImpl) classificationService.newClassification("KEY", "DOMAIN_A", "t1");
classification = (ClassificationImpl) classificationService.newClassification("KEY", "DOMAIN_A", "TASK");
classification.setCategory("Test Classification");
classification.setName("Transfert-Task Classification");
classificationService.createClassification(classification);
@ -392,7 +392,7 @@ public class TaskServiceImplIntExplicitTest {
workbasketService = taskanaEngine.getWorkbasketService();
ClassificationImpl classification = (ClassificationImpl) classificationService.newClassification(
"KEY", "DOMAIN_A", "t1");
"KEY", "DOMAIN_A", "TASK");
classification.setCategory("Test Classification");
classification.setName("Transfert-Task Classification");
classificationService.createClassification(classification);
@ -462,14 +462,14 @@ public class TaskServiceImplIntExplicitTest {
private Task generateDummyTask() throws ClassificationAlreadyExistException, ClassificationNotFoundException,
WorkbasketNotFoundException, InvalidWorkbasketException, NotAuthorizedException,
WorkbasketAlreadyExistException, DomainNotFoundException {
WorkbasketAlreadyExistException, DomainNotFoundException, InvalidArgumentException {
WorkbasketImpl workbasket = (WorkbasketImpl) workbasketService.newWorkbasket("wb", "DOMAIN_A");
workbasket.setName("wb");
workbasket.setId("1"); // set id manually for authorization tests
workbasket.setType(WorkbasketType.GROUP);
taskanaEngine.getWorkbasketService().createWorkbasket(workbasket);
Classification classification = classificationService.newClassification("TEST", "DOMAIN_A", "t1");
Classification classification = classificationService.newClassification("TEST", "DOMAIN_A", "TASK");
taskanaEngine.getClassificationService().createClassification(classification);
Task task = taskServiceImpl.newTask(workbasket.getId());

2
lib/taskana-core/src/test/resources/taskana.properties
View File

@ -3,3 +3,5 @@ taskana.roles.Admin=name=konrad,Organisation=novatec|admin
taskana.roles.businessadmin=max|Moritz|businessadmin
taskana.domains= Domain_A , DOMAIN_B
taskana.classification.types= TASK , document

1
rest/taskana-rest-spring-example/src/main/resources/taskana.properties
View File

@ -2,3 +2,4 @@ taskana.roles.user = group1 | group2|teamlead_1 |teamlead_2 |user_1_1| user_1_1|
taskana.roles.Admin=name=konrad,Organisation=novatec|admin
taskana.roles.businessadmin=max|Moritz|businessadmin
taskana.domains=DOMAIN_A,DOMAIN_B,DOMAIN_C
taskana.classification.types=TASK,DOCUMENT

9
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/ClassificationController.java
View File

@ -26,6 +26,7 @@ import pro.taskana.exceptions.ClassificationAlreadyExistException;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.ConcurrencyException;
import pro.taskana.exceptions.DomainNotFoundException;
import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.rest.resource.ClassificationResource;
import pro.taskana.rest.resource.mapper.ClassificationMapper;
@ -59,7 +60,7 @@ public class ClassificationController {
@Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<ClassificationResource> getClassification(@PathVariable String classificationId)
throws ClassificationNotFoundException, NotAuthorizedException, ClassificationAlreadyExistException,
ConcurrencyException, DomainNotFoundException {
ConcurrencyException, DomainNotFoundException, InvalidArgumentException {
Classification classification = classificationService.getClassification(classificationId);
return ResponseEntity.status(HttpStatus.OK).body(classificationMapper.toResource(classification));
}
@ -68,7 +69,7 @@ public class ClassificationController {
@Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<ClassificationResource> getClassification(@PathVariable String classificationKey,
@PathVariable String domain) throws ClassificationNotFoundException, NotAuthorizedException,
ClassificationAlreadyExistException, ConcurrencyException, DomainNotFoundException {
ClassificationAlreadyExistException, ConcurrencyException, DomainNotFoundException, InvalidArgumentException {
Classification classification = classificationService.getClassification(classificationKey, domain);
return ResponseEntity.status(HttpStatus.OK).body(classificationMapper.toResource(classification));
}
@ -87,7 +88,7 @@ public class ClassificationController {
public ResponseEntity<ClassificationResource> createClassification(
@RequestBody ClassificationResource resource)
throws NotAuthorizedException, ClassificationNotFoundException, ClassificationAlreadyExistException,
ConcurrencyException, DomainNotFoundException {
ConcurrencyException, DomainNotFoundException, InvalidArgumentException {
Classification classification = classificationMapper.toModel(resource);
classification = classificationService.createClassification(classification);
return ResponseEntity.status(HttpStatus.CREATED).body(classificationMapper.toResource(classification));
@ -97,7 +98,7 @@ public class ClassificationController {
@Transactional(rollbackFor = Exception.class)
public ResponseEntity<ClassificationResource> updateClassification(@RequestBody ClassificationResource resource)
throws NotAuthorizedException, ClassificationNotFoundException, ConcurrencyException,
ClassificationAlreadyExistException, DomainNotFoundException {
ClassificationAlreadyExistException, DomainNotFoundException, InvalidArgumentException {
Classification classification = classificationMapper.toModel(resource);
classification = classificationService.updateClassification(classification);
return ResponseEntity.status(HttpStatus.OK).body(classificationMapper.toResource(classification));

7
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/ClassificationDefinitionController.java
View File

@ -26,6 +26,7 @@ import pro.taskana.exceptions.ClassificationAlreadyExistException;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.ConcurrencyException;
import pro.taskana.exceptions.DomainNotFoundException;
import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.rest.resource.ClassificationResource;
import pro.taskana.rest.resource.mapper.ClassificationMapper;
@ -47,7 +48,7 @@ public class ClassificationDefinitionController {
@Transactional(readOnly = true, rollbackFor = Exception.class)
public ResponseEntity<List<ClassificationResource>> getClassifications(
@RequestParam(required = false) String domain) throws ClassificationNotFoundException, NotAuthorizedException,
ClassificationAlreadyExistException, ConcurrencyException, DomainNotFoundException {
ClassificationAlreadyExistException, ConcurrencyException, DomainNotFoundException, InvalidArgumentException {
ClassificationQuery query = classificationService.createClassificationQuery();
List<ClassificationSummary> summaries = domain != null ? query.domainIn(domain).list() : query.list();
List<ClassificationResource> export = new ArrayList<>();
@ -63,7 +64,7 @@ public class ClassificationDefinitionController {
@PostMapping(path = "/import")
@Transactional(rollbackFor = Exception.class)
public ResponseEntity<String> importClassifications(
@RequestBody List<ClassificationResource> classificationResources) {
@RequestBody List<ClassificationResource> classificationResources) throws InvalidArgumentException {
Map<String, String> systemIds = classificationService.createClassificationQuery()
.list()
.stream()
@ -88,7 +89,7 @@ public class ClassificationDefinitionController {
} catch (ClassificationAlreadyExistException e) {
TransactionInterceptor.currentTransactionStatus().setRollbackOnly();
return new ResponseEntity<>(HttpStatus.CONFLICT);
//TODO why is this occuring???
// TODO why is this occuring???
} catch (ConcurrencyException e) {
}

6
rest/taskana-rest-spring/src/main/java/pro/taskana/rest/resource/mapper/ClassificationMapper.java
View File

@ -15,6 +15,7 @@ import pro.taskana.exceptions.ClassificationAlreadyExistException;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.ConcurrencyException;
import pro.taskana.exceptions.DomainNotFoundException;
import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.impl.ClassificationImpl;
import pro.taskana.rest.ClassificationController;
@ -30,7 +31,8 @@ public class ClassificationMapper {
ClassificationService classificationService;
public ClassificationResource toResource(Classification classification) throws ClassificationNotFoundException,
NotAuthorizedException, ClassificationAlreadyExistException, ConcurrencyException, DomainNotFoundException {
NotAuthorizedException, ClassificationAlreadyExistException, ConcurrencyException, DomainNotFoundException,
InvalidArgumentException {
ClassificationResource resource = new ClassificationResource();
BeanUtils.copyProperties(classification, resource);
// need to be set by hand, because they are named different, or have different types
@ -53,7 +55,7 @@ public class ClassificationMapper {
private ClassificationResource addLinks(ClassificationResource resource, Classification classification)
throws ClassificationNotFoundException, NotAuthorizedException, ClassificationAlreadyExistException,
ConcurrencyException, DomainNotFoundException {
ConcurrencyException, DomainNotFoundException, InvalidArgumentException {
resource.add(
linkTo(methodOn(ClassificationController.class).getClassification(classification.getId()))
.withSelfRel());

3
rest/taskana-rest-spring/src/test/java/pro/taskana/rest/resource/mapper/ClassificationMapperTest.java
View File

@ -16,6 +16,7 @@ import pro.taskana.exceptions.ClassificationAlreadyExistException;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.ConcurrencyException;
import pro.taskana.exceptions.DomainNotFoundException;
import pro.taskana.exceptions.InvalidArgumentException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.impl.ClassificationImpl;
import pro.taskana.rest.RestConfiguration;
@ -37,7 +38,7 @@ public class ClassificationMapperTest {
@Test
public void classificationToResource() throws ClassificationNotFoundException, NotAuthorizedException,
ClassificationAlreadyExistException, ConcurrencyException, DomainNotFoundException {
ClassificationAlreadyExistException, ConcurrencyException, DomainNotFoundException, InvalidArgumentException {
// given
ClassificationImpl classification = (ClassificationImpl) classificationService.newClassification("DOMAIN_A",
"1", "A");