TSK-400: added configuration of classification types.

lib/taskana-core/src/main/java/pro/taskana/ClassificationService.java

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

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

@@ -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.
      *

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

@@ -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;
     }
 

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

@@ -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);
         }

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

@@ -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);

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

@@ -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");

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

@@ -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"));
+
+    }
+
 }

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

@@ -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");

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

@@ -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",
+            expectedClassification = (ClassificationImpl) this.createDummyClassificationWithUniqueKey(domain,
-                "type1");
+                "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 {
+        DomainNotFoundException, InvalidArgumentException {
-        Classification classification0 = this.createDummyClassificationWithUniqueKey("", "type1");
+        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 {
+        ConcurrencyException, DomainNotFoundException, InvalidArgumentException {
-        Classification classification = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "type1");
+        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 {
+        DomainNotFoundException, InvalidArgumentException {
-        Classification classification1 = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "type1");
+        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 {
+        DomainNotFoundException, InvalidArgumentException {
-        Classification classification1 = this.createDummyClassificationWithUniqueKey("", "type1");
+        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 {
+        ClassificationNotFoundException, DomainNotFoundException, InvalidArgumentException {
-        Classification classification = this.createDummyClassificationWithUniqueKey("", "type1");
+        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 {
+        ConcurrencyException, DomainNotFoundException, InvalidArgumentException {
-        Classification classification = this.createDummyClassificationWithUniqueKey("DOMAIN_A", "type1");
+        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());

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

@@ -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 = (ClassificationImpl) this.createNewClassificationWithUniqueKey("", "TASK");
-            expectedClassification.setDomain(domain + "_3");
+            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);

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

@@ -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());

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

@@ -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());

lib/taskana-core/src/test/resources/taskana.properties

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

rest/taskana-rest-spring-example/src/main/resources/taskana.properties

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

rest/taskana-rest-spring/src/main/java/pro/taskana/rest/ClassificationController.java

@@ -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));

rest/taskana-rest-spring/src/main/java/pro/taskana/rest/ClassificationDefinitionController.java

@@ -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()

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

@@ -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());

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

@@ -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");